ruby_raider 4.1.0 → 4.2.0

data/spec/utilities/schedules/legacy_spec.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'tmpdir'
+require 'yaml'
+require_relative '../../../lib/utilities/schedules/legacy'
+require_relative '../../../lib/utilities/schedules/project'
+
+# Every adapter here is a recording double, or a real one on a command double and a temp home: nothing
+# reaches launchctl, crontab, systemctl or the real ~/Library/LaunchAgents.
+# rubocop:disable RSpec/MultipleMemoizedHelpers
+RSpec.describe RubyRaider::Schedules::Legacy do # rubocop:disable RSpec/FilePath
+  # Answers list_ids from ids and remove from answers by name (true unless told: false, or an error to raise)
+  let(:fake_adapter_class) do
+    Class.new do
+      attr_reader :calls, :answers
+      attr_accessor :ids, :on_remove
+
+      def initialize(ids = [])
+        @calls = []
+        @ids = ids
+        @answers = {}
+      end
+
+      def list_ids(prefix)
+        @calls << [:list_ids, prefix]
+        ids.select { |id| id.start_with?(prefix) }
+      end
+
+      def remove(os_id)
+        @calls << [:remove, os_id]
+        on_remove&.call(os_id)
+        answer = answers.fetch(os_id.split('.').last, true)
+        raise answer if answer.is_a?(Exception)
+
+        answer
+      end
+    end
+  end
+
+  # Plays launchctl, crontab, systemctl and schtasks: records argv, keeps the crontab, answers from a table by
+  # verb (outputs: the stdout of a verb other than crontab -l)
+  let(:fake_runner_class) do
+    Class.new do
+      attr_reader :calls, :answers, :outputs
+      attr_accessor :table
+
+      def initialize
+        @calls = []
+        @answers = {}
+        @outputs = {}
+      end
+
+      def call(*argv, stdin_data: nil)
+        @calls << argv
+        key = argv.first == '/bin/launchctl' ? argv[1] : argv.reject { |arg| arg == '--user' }.first(2).join(' ')
+        stderr, status = answers.fetch(key) { key == 'crontab -l' && table.nil? ? ['no crontab for raider', 1] : ['', 0] }
+        self.table = stdin_data if key == 'crontab -' && status.zero?
+        stdout = key == 'crontab -l' ? table.to_s : outputs.fetch(key, '')
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: stdout, stderr: stderr, exitstatus: status)
+      end
+    end
+  end
+
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-legacy')) }
+  let(:home) { File.join(tmp, 'home') }
+  let(:agents) { File.join(home, 'Library', 'LaunchAgents') }
+  let(:a_dir) { project_dir('a') }
+  let(:b_dir) { project_dir('b') }
+  let(:err) { StringIO.new }
+  let(:runner) { fake_runner_class.new }
+  let(:kind) { RubyRaider::Schedules::Kind::FLOW_LEGACY }
+  let(:old_rule) { described_class::OldRule }
+
+  after { FileUtils.rm_rf(tmp) }
+
+  def project_dir(name)
+    dir = File.join(tmp, name)
+    FileUtils.mkdir_p(dir)
+    dir
+  end
+
+  def project(dir) = RubyRaider::Schedules::Project.new(dir)
+
+  def os_id(dir, name) = old_rule.os_id_for(dir, name)
+
+  def yml(dir) = File.join(dir, '.raider', 'flows', 'schedules.yml')
+
+  # A 4.1 schedules.yml; each entry a name and its os_id for this project unless given
+  def write_yml(dir, *names, entries: names.map { |name| { 'name' => name, 'every' => 'day', 'at' => '08:00', 'os_id' => os_id(dir, name) } })
+    FileUtils.mkdir_p(File.dirname(yml(dir)))
+    File.write(yml(dir), YAML.dump({ 'schedules' => entries }))
+  end
+
+  def cleanup(dir, adapter, **options) = described_class.new(project(dir), adapter: adapter, err: err).cleanup(**options)
+
+  def removed(*names) = names.map { |name| [:remove, os_id(a_dir, name)] }
+
+  def removed_notice(*names)
+    one = names.size == 1
+    "Removed #{one ? '1 schedule' : "#{names.size} schedules"} made with Ruby Raider 4.1 (#{names.join(', ')}); " \
+      "#{one ? 'it' : 'they'} can't run in 4.2. Add #{one ? 'it' : 'them'} again with raider schedule add."
+  end
+
+  describe 'with launchd' do
+    let(:launchd) { RubyRaider::Schedules::Os::Launchd.new(kind: kind, runner: runner, home: home, uid: 501) }
+
+    def plist(dir, name) = File.join(agents, "#{os_id(dir, name)}.plist")
+
+    def write_plist(path, text = 'x')
+      FileUtils.mkdir_p(agents)
+      File.write(path, text)
+    end
+
+    it "removes only this project's entry when another project has one with the same name" do
+      write_yml(a_dir, 'report')
+      write_plist(plist(a_dir, 'report'))
+      write_plist(plist(b_dir, 'report'), "b's plist")
+
+      notice = cleanup(a_dir, launchd)
+
+      expect(notice).to eq(removed_notice('report'))
+      expect(err.string).to eq("#{removed_notice('report')}\n")
+      expect([File.exist?(plist(a_dir, 'report')), File.read(plist(b_dir, 'report')), File.exist?(yml(a_dir))]).to eq([false, "b's plist", false])
+      expect(runner.calls).to eq([['/bin/launchctl', 'bootout', "gui/501/#{os_id(a_dir, 'report')}"]])
+    end
+
+    it 'never uses an os_id stored in the yml: an entry copied from elsewhere is skipped' do
+      foreign = 'dev.rubyraider.flow.1255a248a3.tredssd'
+      write_yml(a_dir, entries: [{ 'name' => 'tredssd', 'os_id' => foreign }])
+      write_plist(File.join(agents, "#{foreign}.plist"), 'live')
+      write_plist(plist(a_dir, 'tredssd'))
+
+      notice = cleanup(a_dir, launchd)
+
+      expect(notice).to eq(removed_notice('tredssd'))
+      expect(runner.calls.flatten.grep(/1255a248a3/)).to be_empty
+      expect(File.read(File.join(agents, "#{foreign}.plist"))).to eq('live')
+    end
+  end
+
+  it 'never passes a stored os_id to remove' do
+    write_yml(a_dir, entries: [{ 'name' => 'tredssd', 'os_id' => 'dev.rubyraider.flow.1255a248a3.tredssd' }])
+    adapter = fake_adapter_class.new(['dev.rubyraider.flow.1255a248a3.tredssd'])
+
+    expect(cleanup(a_dir, adapter)).to be_nil
+    expect(adapter.calls.flatten.grep(/1255a248a3/)).to be_empty
+  end
+
+  it "keeps the yml of a moved project, whose entries carry the old path's os_ids" do
+    old_dir = project_dir('old')
+    write_yml(a_dir, entries: %w[alpha beta].map { |name| { 'name' => name, 'os_id' => os_id(old_dir, name) } })
+    adapter = fake_adapter_class.new([os_id(old_dir, 'alpha'), os_id(old_dir, 'beta')])
+
+    expect([cleanup(a_dir, adapter), err.string, File.exist?(yml(a_dir))]).to eq([nil, '', true])
+    expect(adapter.calls.map(&:first)).to eq([:list_ids])
+  end
+
+  describe 'with cron' do
+    let(:cron) { RubyRaider::Schedules::Os::Cron.new(kind: kind, runner: runner) }
+
+    def pair(dir, name)
+      "# raider-flow #{os_id(dir, name)}\n" \
+        "0 8 * * * cd #{dir} && /usr/bin/env /r /b exec raider flow run #{name} --project #{dir} --trigger schedule >> /l 2>&1\n"
+    end
+
+    it "removes only this project's tagged pair; every other byte stays" do
+      runner.table = "#{pair(b_dir, 'report')}MAILTO=\"\"\n5 * * * * /usr/bin/backup  --keep\n#{pair(a_dir, 'report')}"
+
+      expect(cleanup(a_dir, cron)).to eq(removed_notice('report'))
+      expect(runner.table).to eq("#{pair(b_dir, 'report')}MAILTO=\"\"\n5 * * * * /usr/bin/backup  --keep\n")
+    end
+  end
+
+  describe 'on Linux, with systemd' do
+    let(:units) { File.join(home, '.config', 'systemd', 'user') }
+    let(:linux) do
+      systemd = RubyRaider::Schedules::Os::Systemd.new(kind: kind, runner: runner, home: home, config_home: nil)
+      RubyRaider::Schedules::Os::Linux.new(kind: kind, runner: runner, systemd: systemd)
+    end
+
+    def unit(dir, name, type) = File.join(units, "#{os_id(dir, name)}.#{type}")
+
+    it "removes only this project's units when another project has one with the same name" do
+      write_yml(a_dir, 'report')
+      FileUtils.mkdir_p(units)
+      [a_dir, b_dir].product(%w[timer service]).each { |dir, type| File.write(unit(dir, 'report', type), "#{dir} #{type}") }
+
+      expect(cleanup(a_dir, linux)).to eq(removed_notice('report'))
+      expect(runner.calls.flatten.grep(/dev\.rubyraider/)).to eq(["#{os_id(a_dir, 'report')}.timer"])
+      expect(%w[timer service].map { |type| File.exist?(unit(a_dir, 'report', type)) }).to eq([false, false])
+      expect(%w[timer service].map { |type| File.read(unit(b_dir, 'report', type)) }).to eq(["#{b_dir} timer", "#{b_dir} service"])
+    end
+  end
+
+  describe 'with Task Scheduler' do
+    let(:schtasks) { 'C:\\Windows\\System32\\schtasks.exe' }
+    let(:task_scheduler) { RubyRaider::Schedules::Os::TaskScheduler.new(kind: kind, runner: runner, schtasks: schtasks) }
+
+    def task(dir, name) = "\\RubyRaider\\#{os_id(dir, name)}"
+
+    it "deletes only this project's task when another project has one with the same name" do
+      write_yml(a_dir, 'report')
+      runner.outputs["#{schtasks} /Query"] = [task(b_dir, 'report'), task(a_dir, 'report')]
+                                             .map { |name| %("#{name}","11/10/2026 8:00:00 AM","Ready"\r\n) }.join
+
+      expect(cleanup(a_dir, task_scheduler)).to eq(removed_notice('report'))
+      expect(runner.calls.select { |argv| argv[1] == '/Delete' }).to eq([[schtasks, '/Delete', '/TN', task(a_dir, 'report'), '/F']])
+    end
+  end
+
+  describe 'on Linux, cron with systemd unit files left behind' do
+    let(:units) { File.join(home, '.config', 'systemd', 'user') }
+    let(:linux) do
+      systemd = RubyRaider::Schedules::Os::Systemd.new(kind: kind, runner: runner, home: home, config_home: nil)
+      RubyRaider::Schedules::Os::Linux.new(kind: kind, runner: runner, systemd: systemd)
+    end
+    let(:stranded) do
+      'Could not remove 1 schedule made with Ruby Raider 4.1 (report: This schedule is a systemd timer; run raider schedule list ' \
+        'from a session where systemctl --user works); it is tried again next time.'
+    end
+
+    before do
+      runner.answers['systemctl show-environment'] = ['Failed to connect to bus', 1]
+      FileUtils.mkdir_p(units)
+      File.write(File.join(units, "#{os_id(a_dir, 'report')}.timer"), 'x')
+    end
+
+    it 'reports the failure, keeps the yml, and tries again next time' do
+      write_yml(a_dir, 'report')
+
+      first = cleanup(a_dir, linux)
+      FileUtils.rm_f(yml(a_dir))
+      second = cleanup(a_dir, linux)
+
+      expect([first, second]).to eq([stranded, stranded])
+      expect(err.string.lines).to eq(["#{stranded}\n", "#{stranded}\n"])
+      expect(File.exist?(File.join(units, "#{os_id(a_dir, 'report')}.timer"))).to be(true)
+    end
+
+    it 'keeps the yml' do
+      write_yml(a_dir, 'report')
+      cleanup(a_dir, linux)
+
+      expect(File.exist?(yml(a_dir))).to be(true)
+    end
+  end
+
+  describe 'a failed removal' do
+    it 'keeps the yml; a later run deletes it and reports only what it removed then' do
+      write_yml(a_dir, 'alpha', 'beta')
+      adapter = fake_adapter_class.new
+      adapter.answers['beta'] = RubyRaider::Schedules::Error.new("busy\nnow")
+
+      first = cleanup(a_dir, adapter)
+      kept = File.exist?(yml(a_dir))
+      adapter.answers.replace('alpha' => false)
+      second = cleanup(a_dir, adapter)
+
+      expect(first).to eq("#{removed_notice('alpha')} Could not remove 1 schedule made with Ruby Raider 4.1 (beta: busy?now); it is tried again next time.")
+      expect([kept, second, File.exist?(yml(a_dir))]).to eq([true, removed_notice('beta'), false])
+      expect(err.string.lines.size).to eq(2)
+    end
+
+    it 'counts in the plural' do
+      write_yml(a_dir, 'alpha', 'beta')
+      adapter = fake_adapter_class.new
+      adapter.answers.replace('alpha' => RubyRaider::Schedules::Error.new('x'), 'beta' => RubyRaider::Schedules::Error.new('y'))
+
+      expect(cleanup(a_dir, adapter))
+        .to eq('Could not remove 2 schedules made with Ruby Raider 4.1 (alpha: x, beta: y); they are tried again next time.')
+    end
+
+    it 'names every schedule it removed, from the yml and the OS, sorted' do
+      write_yml(a_dir, 'beta')
+      adapter = fake_adapter_class.new([os_id(a_dir, 'alpha'), os_id(a_dir, 'beta')])
+
+      expect(cleanup(a_dir, adapter)).to eq(removed_notice('alpha', 'beta'))
+      expect(adapter.calls.drop(1)).to eq(removed('alpha', 'beta'))
+    end
+  end
+
+  describe 'with nothing to clean' do
+    it 'is nil, prints nothing, creates or deletes nothing, and only enumerates' do
+      adapter = fake_adapter_class.new
+      FileUtils.mkdir_p(File.join(a_dir, 'flows'))
+      before = Dir.glob('**/*', File::FNM_DOTMATCH, base: tmp).sort
+
+      expect(cleanup(a_dir, adapter)).to be_nil
+      expect([err.string, Dir.glob('**/*', File::FNM_DOTMATCH, base: tmp).sort]).to eq(['', before])
+      expect(adapter.calls).to eq([[:list_ids, old_rule.os_id_prefix_for(a_dir)]])
+    end
+
+    it 'is nil when the entries are already gone, and deletes the yml' do
+      write_yml(a_dir, 'report')
+      adapter = fake_adapter_class.new
+      adapter.answers['report'] = false
+
+      expect([cleanup(a_dir, adapter), err.string, File.exist?(yml(a_dir))]).to eq([nil, '', false])
+    end
+
+    it 'deletes an empty schedules file' do
+      results = ['', "schedules: []\n"].map do |text|
+        FileUtils.mkdir_p(File.dirname(yml(a_dir)))
+        File.write(yml(a_dir), text)
+        [cleanup(a_dir, fake_adapter_class.new), File.exist?(yml(a_dir))]
+      end
+
+      expect([results, err.string]).to eq([[[nil, false], [nil, false]], ''])
+    end
+
+    it 'does nothing where there is no OS scheduler' do
+      write_yml(a_dir, 'report')
+      allow(RubyRaider::Schedules).to receive(:adapter).and_raise(RubyRaider::Schedules::Error, 'Scheduling 4.1 schedules is not supported on solaris')
+
+      expect([described_class.new(project(a_dir), err: err).cleanup, err.string, File.exist?(yml(a_dir))]).to eq([nil, '', true])
+      expect(RubyRaider::Schedules).to have_received(:adapter).with(kind: kind)
+    end
+  end
+
+  describe 'a yml it does not read' do
+    let(:adapter) { fake_adapter_class.new }
+
+    it 'skips .raider/flows when it is a link to another folder, and leaves what is there' do
+      outside = project_dir('outside')
+      write_yml(outside, entries: [{ 'name' => 'report', 'os_id' => os_id(a_dir, 'report') }])
+      FileUtils.mkdir_p(File.join(a_dir, '.raider'))
+      File.symlink(File.join(outside, '.raider', 'flows'), File.join(a_dir, '.raider', 'flows'))
+
+      expect(cleanup(a_dir, adapter)).to be_nil
+      expect([adapter.calls.map(&:first), File.exist?(yml(outside))]).to eq([[:list_ids], true])
+    end
+
+    it 'skips a schedules.yml that is a link, and leaves it' do
+      outside = project_dir('outside')
+      write_yml(outside, entries: [{ 'name' => 'report', 'os_id' => os_id(a_dir, 'report') }])
+      FileUtils.mkdir_p(File.dirname(yml(a_dir)))
+      File.symlink(yml(outside), yml(a_dir))
+
+      expect(cleanup(a_dir, adapter)).to be_nil
+      expect([adapter.calls.map(&:first), File.symlink?(yml(a_dir)), File.exist?(yml(outside))]).to eq([[:list_ids], true, true])
+    end
+
+    it 'skips entries that are not 4.1 ones, and a file that is too big or not YAML' do
+      write_yml(a_dir, entries: [{ 'name' => 123, 'os_id' => os_id(a_dir, '123') }, { 'name' => 'env', 'os_id' => os_id(a_dir, 'env') },
+                                 { 'name' => 'Caps', 'os_id' => os_id(a_dir, 'Caps') }, { 'name' => 'nameless' }, 'report'])
+      results = [[cleanup(a_dir, adapter), File.exist?(yml(a_dir))]]
+      ["schedules: [\n", "schedules:\n  - name: #{'a' * 1_000_001}\n", "schedules: report\n", "- report\n"].each do |text|
+        File.write(yml(a_dir), text)
+        results << [cleanup(a_dir, adapter), File.exist?(yml(a_dir))]
+      end
+
+      expect(results).to all(eq([nil, true]))
+      expect(adapter.calls.map(&:first).uniq).to eq([:list_ids])
+    end
+  end
+
+  it "leaves the user's files" do
+    write_yml(a_dir, 'report')
+    kept = %w[flows/login.yml flow-results/run.json .raider/flows/env .raider/flows/report/scheduler.log .raider/tests/flows/x.rb]
+    kept.each do |path|
+      FileUtils.mkdir_p(File.dirname(File.join(a_dir, path)))
+      File.write(File.join(a_dir, path), path)
+    end
+
+    expect(cleanup(a_dir, fake_adapter_class.new)).to eq(removed_notice('report'))
+    expect(kept.map { |path| File.read(File.join(a_dir, path)) }).to eq(kept)
+    expect(File.exist?(yml(a_dir))).to be(false)
+  end
+
+  it 'turns an unexpected error into one printed line, never raising' do
+    write_yml(a_dir, 'report')
+    adapter = fake_adapter_class.new
+    adapter.answers['report'] = RuntimeError.new("odd\e[2J")
+
+    expect(cleanup(a_dir, adapter)).to eq('Could not remove the schedules made with Ruby Raider 4.1: odd?[2J')
+    expect([err.string, File.exist?(yml(a_dir))]).to eq(["Could not remove the schedules made with Ruby Raider 4.1: odd?[2J\n", true])
+  end
+
+  describe 'its own entry (last)' do
+    let(:events) { [] }
+    let(:recording_err) do
+      log = events
+      Class.new do
+        define_method(:puts) { |text| log << [:puts, text] }
+        define_method(:flush) { log << [:flush] }
+      end.new
+    end
+    let(:adapter) do
+      fake_adapter_class.new([os_id(a_dir, 'report'), os_id(a_dir, 'other')]).tap do |double|
+        log = events
+        path = yml(a_dir)
+        double.on_remove = ->(id) { log << [:remove, id.split('.').last, File.exist?(path)] }
+      end
+    end
+
+    def own_cleanup = described_class.new(project(a_dir), adapter: adapter, err: recording_err).cleanup(last: 'report')
+
+    it 'is counted, and removed after the notice is out and the yml deleted' do
+      write_yml(a_dir, 'report')
+
+      notice = own_cleanup
+
+      expect(notice).to eq(removed_notice('other', 'report'))
+      expect(events).to eq([[:remove, 'other', true], [:puts, notice], [:flush], [:remove, 'report', false]])
+    end
+
+    it 'says so on a second line when it can not be removed' do
+      adapter.answers['report'] = RubyRaider::Schedules::Error.new('denied')
+
+      own_cleanup
+
+      expect(events.select { |event| event.first == :puts }.map(&:last)).to eq([removed_notice('other', 'report'), 'Could not remove report: denied'])
+    end
+
+    it 'is not removed when it is not one of the names' do
+      adapter.ids = [os_id(a_dir, 'other')]
+
+      expect(described_class.new(project(a_dir), adapter: adapter, err: err).cleanup(last: 'report')).to eq(removed_notice('other'))
+      expect(adapter.calls.drop(1)).to eq(removed('other'))
+    end
+  end
+
+  it 'prints no flow word' do
+    write_yml(a_dir, 'alpha', 'beta')
+    adapter = fake_adapter_class.new
+    adapter.answers['beta'] = RubyRaider::Schedules::Error.new('busy')
+    cleanup(a_dir, adapter)
+
+    expect(err.string).not_to match(/\bflows?\b/i)
+  end
+end
+# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/utilities/schedules/legacy_stub_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'tmpdir'
+require_relative '../../../lib/ruby_raider'
+require_relative '../../../lib/utilities/schedules/legacy_stub'
+require_relative '../../../lib/utilities/schedules/notifier'
+
+# Through RubyRaider::Raider.start, as `raider flow ...` from a 4.1 OS entry reaches it. Legacy always gets a
+# recording adapter: nothing reaches the OS scheduler.
+# rubocop:disable RSpec/MultipleMemoizedHelpers
+RSpec.describe RubyRaider::Schedules::LegacyStub do # rubocop:disable RSpec/FilePath
+  let(:fake_adapter_class) do
+    Class.new do
+      attr_reader :ids, :removed
+
+      def initialize(ids)
+        @ids = ids
+        @removed = []
+      end
+
+      def list_ids(prefix) = ids.select { |id| id.start_with?(prefix) }
+
+      def remove(os_id)
+        @removed << os_id.split('.').last
+        true
+      end
+    end
+  end
+  let(:dir) { File.realpath(Dir.mktmpdir('legacy-stub')) }
+  let(:adapter) { fake_adapter_class.new(%w[other tredssd].map { |name| os_id(name) }) }
+  let(:removed_line) { 'This command was removed in Ruby Raider 4.2. To run tests on a schedule, use raider schedule add.' }
+  let(:notice) do
+    "Removed 2 schedules made with Ruby Raider 4.1 (other, tredssd); they can't run in 4.2. Add them again with raider schedule add."
+  end
+
+  before do
+    File.write(File.join(dir, 'Gemfile'), "source 'https://rubygems.org'\n")
+    allow(RubyRaider::Schedules::Legacy).to receive(:new).and_wrap_original do |original, project, **options|
+      original.call(project, adapter: adapter, **options)
+    end
+    expect(RubyRaider::Schedules::Notifier).not_to receive(:new) # rubocop:disable RSpec/ExpectInHook
+  end
+
+  after { FileUtils.rm_rf(dir) }
+
+  def os_id(name) = RubyRaider::Schedules::Legacy::OldRule.os_id_for(dir, name)
+
+  # [stdout, stderr, exit code or nil when it did not exit]
+  def raider(*args)
+    out = StringIO.new
+    err = StringIO.new
+    stdout = $stdout
+    stderr = $stderr
+    $stdout = out
+    $stderr = err
+    code = begin
+      RubyRaider::Raider.start(args)
+      nil
+    rescue SystemExit => e
+      e.status
+    ensure
+      $stdout = stdout
+      $stderr = stderr
+    end
+    [out.string, err.string, code]
+  end
+
+  it "removes the project's 4.1 schedules, its own last, and exits 2 with the notice on stderr" do
+    result = raider('flow', 'run', 'tredssd', '--project', dir, '--trigger', 'schedule', '--retries', '1', '--notify', '--input', 'a=b')
+
+    expect(result).to eq(['', "#{notice}\n", 2])
+    expect(adapter.removed).to eq(%w[other tredssd])
+  end
+
+  it 'takes --project=VALUE, and f' do
+    result = raider('f', 'run', 'tredssd', "--project=#{dir}", '--trigger', 'schedule')
+
+    expect(result).to eq(['', "#{notice}\n", 2])
+  end
+
+  it 'takes the first --project only' do
+    result = raider('flow', 'run', 'tredssd', '--project', dir, '--project', '/nonexistent')
+
+    expect(result).to eq(['', "#{notice}\n", 2])
+  end
+
+  it 'still cleans up with invalid UTF-8 in another argument' do
+    result = raider('flow', 'run', "a\xFF", '--project', dir, '--input', "x=\xFF")
+
+    expect(result).to eq(['', "#{notice}\n", 2])
+  end
+
+  it 'says none was found for the project when there is nothing to remove' do
+    adapter.ids.clear
+
+    result = raider('flow', 'run', 'tredssd', '--project', dir, '--trigger', 'schedule')
+
+    expect(result).to eq(['', "This schedule was made with Ruby Raider 4.1 and can't run in 4.2, and none was found for #{dir} " \
+                              "to remove: see Upgrading from 4.1 in the README.\n", 2])
+  end
+
+  it 'exits 2 even when the cleanup misbehaves' do
+    allow(RubyRaider::Schedules::Legacy).to receive(:new).and_raise(RuntimeError, 'odd')
+
+    expect(raider('flow', 'run', 'tredssd', '--project', dir).last).to eq(2)
+  end
+
+  describe 'without a usable project' do
+    let(:no_gemfile) { File.realpath(Dir.mktmpdir('legacy-stub-bare')) }
+
+    after { FileUtils.rm_rf(no_gemfile) }
+
+    it 'says the command was removed, exits 2 and cleans up nothing, whatever the argv' do
+      gemfile_dir = File.realpath(Dir.mktmpdir('legacy-stub-gemfile-dir'))
+      FileUtils.mkdir_p(File.join(gemfile_dir, 'Gemfile'))
+      argvs = [%w[flow], %w[f], %w[flow --help], %w[flow help], %w[flow run tredssd --project], ['flow', 'run', 'tredssd', '--project', "#{dir}\xFF"],
+               %w[flow run tredssd --project relative/dir], %w[flow run tredssd --project /nonexistent/raider],
+               ['flow', 'run', 'tredssd', '--project', no_gemfile], ['flow', 'run', 'tredssd', '--project', gemfile_dir],
+               ['flow', 'run', 'tredssd', '--project', "#{dir}\0"], %w[flow run tredssd --retries 1 --notify --input a=b]]
+
+      results = argvs.map { |argv| raider(*argv) }
+
+      expect(results).to all(eq(['', "#{removed_line}\n", 2]))
+      expect(RubyRaider::Schedules::Legacy).not_to have_received(:new)
+    ensure
+      FileUtils.rm_rf(gemfile_dir)
+    end
+
+    it 'never takes the current folder' do
+      result = Dir.chdir(dir) { raider('flow', 'run', 'tredssd', '--trigger', 'schedule') }
+
+      expect(result).to eq(['', "#{removed_line}\n", 2])
+      expect(adapter.removed).to be_empty
+    end
+  end
+
+  it 'is not in raider help' do
+    out, = raider('help')
+
+    expect(out).not_to match(/\bflows?\b/)
+  end
+end
+# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/utilities/{flows → schedules}/next_run_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require_relative '../../../lib/utilities/flows/next_run'
+require_relative '../../../lib/utilities/schedules/next_run'
+require_relative '../../../lib/utilities/schedules/schedule'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
-RSpec.describe RubyRaider::Flows::NextRun do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::NextRun do # rubocop:disable RSpec/FilePath
   let(:dir) { File.realpath(Dir.mktmpdir('flows-next-run')) }
-  let(:project) { RubyRaider::Flows::Project.new(dir) }
+  let(:project) { RubyRaider::Schedules::Project.new(dir) }
 
   around do |example|
     zone = ENV.fetch('TZ', nil)
@@ -19,7 +19,7 @@ RSpec.describe RubyRaider::Flows::NextRun do # rubocop:disable RSpec/FilePath
   after { FileUtils.rm_rf(dir) }
 
   def rule(every, at = '08:00', on: nil)
-    RubyRaider::Flows::Schedule.build(project: project, name: 'report', every: every, at: at, on: on)
+    RubyRaider::Schedules::Schedule.build(project: project, name: 'report', every: every, at: at, on: on)
   end
 
   def next_after(schedule, *local)

data/spec/utilities/{flows → schedules}/notifier_spec.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 require 'stringio'
-require_relative '../../../lib/utilities/flows/notifier'
+require_relative '../../../lib/utilities/schedules/notifier'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
-RSpec.describe RubyRaider::Flows::Notifier do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Notifier do # rubocop:disable RSpec/FilePath
   # Records each command instead of running it: no real osascript, notify-send or PowerShell
   let(:runner) do
     Class.new do
@@ -18,7 +17,7 @@ RSpec.describe RubyRaider::Flows::Notifier do # rubocop:disable RSpec/FilePath
 
       def call(*argv, env: {}, timeout: nil, **)
         @calls << { argv: argv, env: env, timeout: timeout }
-        RubyRaider::Flows::Os::CommandRunner::Result.new(stdout: '', stderr: 'no notification server', exitstatus: exitstatus)
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: '', stderr: 'no notification server', exitstatus: exitstatus)
       end
     end.new
   end

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

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 require 'rbconfig'
-require_relative '../../../../lib/utilities/flows/os/command_runner'
+require_relative '../../../../lib/utilities/schedules/os/command_runner'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
-RSpec.describe RubyRaider::Flows::Os::CommandRunner do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Os::CommandRunner do # rubocop:disable RSpec/FilePath
   let(:runner) { described_class.new }
   let(:ruby) { RbConfig.ruby }