ruby_raider 4.1.0 → 4.2.0

data/sig/utilities/schedules/run_wrapper.rbs

@@ -0,0 +1,45 @@
+module RubyRaider
+  module Schedules
+    class RunWrapper
+      EXIT_CODES: Hash[String, Integer]
+      TRIGGERS: Array[String]
+      LOG_BYTES: Integer
+      MISSING: String
+      ZERO: Hash[String, Integer]
+      SPAWNER: ^(Hash[String, String?], Array[String], String) -> [Integer?, bool]
+
+      @project: Project
+      @out: IO | StringIO
+      @err: IO | StringIO
+      @spawner: untyped
+      @clock: ^() -> Time
+      @notifier: untyped
+      @lock: RunLock
+
+      def initialize: (Project project, ?out: IO | StringIO, ?err: IO | StringIO, ?spawner: untyped, ?clock: ^() -> Time, ?notifier: untyped) -> void
+      def run: (String name, ?trigger: String) -> Integer
+
+      private
+
+      def load: (String name) -> Schedule
+      def attempt: (Schedule schedule, Hash[String, String] record) -> Hash[Symbol, untyped]
+      def stopped: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome) -> Hash[Symbol, untyped]
+      def spawn: (Schedule schedule) -> Hash[Symbol, untyped]
+      def status: (Integer? code, bool stopped, Hash[String, Integer]? counts) -> String
+      def argv: (Schedule schedule) -> Array[String]
+      def env: (Schedule schedule) -> Hash[String, String?]
+      def gem_env: (Schedule schedule) -> Hash[String, String?]
+      def copy_report: (Schedule schedule, RunReport? report) -> String?
+      def append: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome) -> void
+      def finish: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome) -> Integer
+      def append_quietly: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome) -> void
+      def result_text: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome) -> String
+      def failures: (Hash[String, Integer] counts) -> String
+      def tests: (Integer total) -> String
+      def notify: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome) -> bool
+      def start_reason: (Schedule schedule, Hash[String, String] record, Hash[Symbol, untyped] outcome, long: bool) -> String
+      def rotate_log: (Schedule schedule) -> void
+      def stamp: () -> String
+    end
+  end
+end

data/sig/utilities/schedules/schedule.rbs

@@ -0,0 +1,27 @@
+module RubyRaider
+  module Schedules
+    class Schedule < Rule
+      KIND: Kind
+      KEYS: Array[String]
+      LINUX: Regexp
+      NO_BROWSER_ON_LINUX: String
+
+      attr_reader show_browser: bool
+      attr_reader selection: Selection
+
+      def self.kind: () -> Kind
+      def self.build: (project: Project, name: String, every: String, ?at: String?, ?on: String?, ?retries: untyped, ?notify: bool, ?show_browser: bool,
+                       ?selection: Selection, ?now: Time, ?host_os: String) -> Schedule
+      def self.from_h: (untyped hash, String project_root, ?host_os: String) -> Schedule
+
+      def initialize: (name: untyped, every: untyped, at: untyped, on: untyped, retries: untyped, selection: untyped, os_id: untyped, ruby: untyped, bundle: untyped,
+                       gem_env: untyped, project_root: untyped, created_at: untyped, ?notify: untyped, ?show_browser: untyped) -> void
+      def to_h: () -> Hash[String, untyped]
+
+      private
+
+      def checked_name: (untyped name) -> String
+      def checked_selection: (untyped selection) -> Selection
+    end
+  end
+end

data/sig/utilities/schedules/schedule_store.rbs

@@ -0,0 +1,21 @@
+module RubyRaider
+  module Schedules
+    class ScheduleStore < Store
+      DIR: String
+      GITIGNORE_LINE: String
+
+      def initialize: (Project project) -> void
+      def all: () -> Array[Schedule]
+      def find: (String name) -> Schedule?
+      def save: (Schedule schedule) -> Schedule
+      def delete: (String name) -> (Schedule | Store::Removed)?
+      def ignore_in_git: () -> bool
+
+      private
+
+      def gitignore: () -> String
+      def gitignore_text: (File file) -> String
+      def ignored?: (String content) -> bool
+    end
+  end
+end

data/sig/utilities/{flows → schedules}/scheduler.rbs

@@ -1,11 +1,15 @@
 module RubyRaider
-  module Flows
+  module Schedules
     class Scheduler
-      NOT_SET_UP: String
-      RUBY_NOT_FOUND: String
-      FLOW_NOT_FOUND: String
-      LAST: Array[String]
+      include SchedulerSteps
+
+      KIND: Kind
       TIME: String
+      LIST_TIME: String
+      LAST: Array[String]
+      EMPTY: String
+      UNLISTED: String
+      RULE_KEYS: Array[String]
 
       type row = { json: Hash[String, untyped], text: String }
 
@@ -15,28 +19,31 @@ module RubyRaider
       @out: IO | StringIO
       @err: IO | StringIO
       @now: ^() -> Time
+      @host_os: String
 
       def self.adapter: (?runner: Os::CommandRunner, ?host_os: String) -> (Os::Launchd | Os::TaskScheduler | Os::Linux)
 
-      def initialize: (Project project, ?adapter: untyped, ?store: ScheduleStore, ?out: IO | StringIO, ?err: IO | StringIO, ?now: ^() -> Time) -> void
-      def schedule: (String name, every: String?, ?at: String?, ?on: String?, ?retries: untyped, ?inputs: Array[String], ?notify: bool) -> void
-      def unschedule: (String name) -> void
-      def schedules: (?json: bool) -> void
+      def initialize: (Project project, ?adapter: untyped, ?store: ScheduleStore, ?out: IO | StringIO, ?err: IO | StringIO, ?now: ^() -> Time,
+                       ?host_os: String) -> void
+      def add: (String name, every: String?, ?files: Array[String], ?tag: String?, ?at: String?, ?on: String?, ?retries: untyped, ?notify: bool,
+                ?show_browser: bool) -> void
+      def remove: (String name) -> void
+      def list: (?json: bool, ?notice: String?) -> void
 
       private
 
+      attr_reader store: ScheduleStore
+
       def adapter: () -> untyped
-      def save: (Schedule schedule) -> Schedule
-      def delete: (String name, String label) -> (Schedule | ScheduleStore::Removed)?
-      def flow_dir: (String name) -> void
-      def private_dir: (String relative) -> void
+      def checked_name: (untyped name) -> void
+      def schedule_dirs: (String name) -> void
+      def ignore_in_git: () -> void
       def row: (Schedule schedule, Time now) -> row
       def unlisted_rows: (Array[String] listed) -> Array[row]
-      def present?: (String os_id) -> bool
+      def unlisted_names: () -> Array[String]
       def os_state: (Schedule schedule) -> String
       def rule: (Schedule schedule) -> String
       def last_run: (String name) -> Hash[String, untyped]?
-      def line: (String name, String rule, String next_run, Hash[String, untyped]? last, String state) -> String
     end
   end
 end

data/sig/utilities/schedules/scheduler_steps.rbs

@@ -0,0 +1,22 @@
+module RubyRaider
+  module Schedules
+    module SchedulerSteps
+      RUBY_NOT_FOUND: String
+
+      private
+
+      # Given by the includer
+      def adapter: () -> untyped
+      def store: () -> Store
+
+      def save: (untyped schedule) -> untyped
+      def delete: (String name, String label) -> untyped
+      def unreadable_warning: (String name, String label) -> String
+      def ruby_found?: (untyped schedule) -> bool
+      def os_entry_state: (String os_id) -> String
+      def present?: (String os_id) -> bool
+      def missed_runs_note: () -> String?
+      def line: (String name, String rule, String next_run, Hash[String, untyped]? last, String state) -> String
+    end
+  end
+end

data/sig/utilities/schedules/selection.rbs

@@ -0,0 +1,36 @@
+module RubyRaider
+  module Schedules
+    class Selection
+      KINDS: Array[String]
+      KEYS: Array[String]
+      TAG: Regexp
+      MAX_FILES: Integer
+      WINDOWS: Regexp
+      FILE_RULE: String
+      WINDOWS_RULE: String
+
+      attr_reader kind: String
+      attr_reader tag: String?
+      attr_reader files: Array[String]
+
+      def self.all: () -> Selection
+      def self.parse: (files: untyped, tag: untyped, root: String, ?host_os: String) -> Selection
+      def self.from_h: (untyped hash, root: String, ?host_os: String) -> Selection
+
+      def initialize: (kind: untyped, ?tag: untyped, ?files: untyped, ?host_os: String) -> void
+      def missing_file: (String root) -> String?
+      def check!: (String root) -> self
+      def to_h: () -> Hash[String, untyped]
+
+      private
+
+      def nothing: (String label, untyped value) -> nil
+      def checked_tag: (untyped tag) -> String
+      def checked_files: (untyped files, bool windows) -> Array[String]
+      def checked_file: (untyped file, bool windows) -> String
+      def spec_path?: (untyped file, bool windows) -> bool
+      def relative?: (String file, bool windows) -> bool
+      def present?: (String root, String file) -> bool
+    end
+  end
+end

data/sig/utilities/schedules/spawn.rbs

@@ -0,0 +1,10 @@
+module RubyRaider
+  module Schedules
+    module Spawn
+      def self.call: (Hash[String, String?] env, Array[String] argv, String chdir, ?forward_int: bool) -> [Integer?, bool]
+      def self.run: (Hash[String, String?] env, Array[String] argv, String chdir, Hash[Symbol, untyped] state, bool forward_int) -> Integer?
+      def self.stop: (Hash[Symbol, untyped] state, String signal, bool forward_int) -> void
+      def self.interrupt: (Hash[Symbol, untyped] state) -> void
+    end
+  end
+end

data/sig/utilities/{flows/schedule_store.rbs → schedules/store.rbs}

@@ -1,7 +1,6 @@
 module RubyRaider
-  module Flows
-    class ScheduleStore
-      DIR: String
+  module Schedules
+    class Store
       FILE: String
       NOFOLLOW: Integer
       NONBLOCK: Integer
@@ -13,16 +12,22 @@ module RubyRaider
         def initialize: (String name, String os_id) -> void
       end
 
-      def initialize: (Project project) -> void
-      def all: () -> Array[Schedule]
-      def find: (String name) -> Schedule?
-      def save: (Schedule schedule) -> Schedule
+      @project: Project
+      @schedule_class: untyped
+      @dir: String
+      @file: String
+
+      def initialize: (Project project, untyped schedule_class) -> void
+      def all: () -> Array[untyped]
+      def find: (String name) -> untyped
+      def save: (untyped schedule) -> untyped
       def writable!: () -> nil
-      def delete: (String name) -> (Schedule | Removed)?
+      def delete: (String name) -> untyped
 
       private
 
-      def from_entry: (untyped entry) -> Schedule?
+      attr_reader project: Project
+      def from_entry: (untyped entry) -> untyped
       def named?: (untyped entry, String name) -> bool
       def read_entries: () -> Array[untyped]?
       def writable_entries: () -> Array[untyped]

data/spec/commands/schedule_commands_spec.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'tmpdir'
+require_relative '../../lib/ruby_raider'
+require_relative '../../lib/commands/schedule_commands'
+
+# Runs in this process through RubyRaider::Raider.start, so the `raider schedule` subcommand path is the real
+# one (thor 1.2.2). Every example stubs Scheduler.new, RunWrapper.new and Legacy.new (or gives Legacy a
+# recording adapter): nothing reaches the OS scheduler or spawns rspec.
+RSpec.describe ScheduleCommands do
+  let(:scheduler) { instance_double(RubyRaider::Schedules::Scheduler, add: nil, list: nil, remove: nil) }
+  let(:wrapper) { instance_double(RubyRaider::Schedules::RunWrapper, run: 0) }
+  let(:legacy) { instance_double(RubyRaider::Schedules::Legacy, cleanup: nil) }
+  let(:dir) { File.realpath(Dir.mktmpdir('schedule-commands')) }
+
+  before do
+    allow(RubyRaider::Schedules::Scheduler).to receive(:new).and_return(scheduler)
+    allow(RubyRaider::Schedules::RunWrapper).to receive(:new).and_return(wrapper)
+    allow(RubyRaider::Schedules::Legacy).to receive(:new).and_return(legacy)
+  end
+
+  after { FileUtils.rm_rf(dir) }
+
+  # [stdout, stderr, exit code or nil when the command 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
+
+  def project_root
+    satisfy { |project| project.root == dir }
+  end
+
+  describe 'add' do
+    it 'takes the spec files and the options in any order' do
+      raider('schedule', 'add', 'nightly', '--every', 'day', 'spec/a_spec.rb', '--show-browser', 'spec/b_spec.rb',
+             '--project', dir)
+
+      expect(scheduler).to have_received(:add).with('nightly', every: 'day', files: %w[spec/a_spec.rb spec/b_spec.rb],
+                                                               tag: nil, at: nil, on: nil, retries: 0, notify: false,
+                                                               show_browser: true)
+      expect(RubyRaider::Schedules::Scheduler).to have_received(:new).with(project_root)
+    end
+
+    it 'passes --at, --on, --tag, --retries and --notify' do
+      raider('schedule', 'add', 'smoke', '--tag', 'smoke', '--every', 'week', '--on', 'mon', '--at', '08:30',
+             '--retries', '2', '--notify', '--project', dir)
+
+      expect(scheduler).to have_received(:add).with('smoke', every: 'week', files: [], tag: 'smoke', at: '08:30',
+                                                             on: 'mon', retries: 2, notify: true, show_browser: false)
+    end
+
+    it 'is reached through raider sc' do
+      raider('sc', 'add', 'nightly', '--every', 'day', '--project', dir)
+
+      expect(scheduler).to have_received(:add).with('nightly', hash_including(every: 'day', files: []))
+    end
+
+    it 'exits 2 with one stderr line when --every is left out' do
+      # The real Scheduler refuses; its adapter is a double that fails on any call
+      allow(RubyRaider::Schedules::Scheduler).to receive(:new).and_wrap_original do |original, project|
+        original.call(project, adapter: instance_double(RubyRaider::Schedules::Os::Launchd), out: $stdout, err: $stderr)
+      end
+
+      out, err, code = raider('schedule', 'add', 'nightly', '--at', '08:00', '--project', dir)
+
+      expect([out, err, code]).to eq(['', "Invalid every nil: use hour, day, weekday or week\n", 2])
+    end
+
+    it 'exits 2 with one stderr line when the project has no Gemfile, before the OS scheduler is touched' do
+      allow(RubyRaider::Schedules::Scheduler).to receive(:new).and_wrap_original do |original, project|
+        original.call(project, adapter: instance_double(RubyRaider::Schedules::Os::Launchd), out: $stdout, err: $stderr)
+      end
+      version = File.read(File.expand_path('../../lib/version', __dir__)).strip
+
+      out, err, code = raider('schedule', 'add', 'nightly', '--every', 'day', '--at', '08:00', '--project', dir)
+
+      expect([out, err, code]).to eq(['', "Scheduling needs ruby_raider #{version} or later in this project: no Gemfile found\n", 2])
+      expect(File.exist?(File.join(dir, '.raider'))).to be(false)
+    end
+  end
+
+  describe 'refusals' do
+    it 'exits 2 with the error on one stderr line' do
+      allow(scheduler).to receive(:remove).and_raise(RubyRaider::Schedules::Error, 'No schedule gone')
+
+      out, err, code = raider('schedule', 'remove', 'gone', '--project', dir)
+
+      expect([out, err, code]).to eq(['', "No schedule gone\n", 2])
+    end
+
+    it 'keeps a --project with a newline on one stderr line' do
+      out, err, code = raider('schedule', 'list', '--project', "/nonexistent/a\nb")
+
+      expect([out, err, code]).to eq(['', "Project folder not found: /nonexistent/a?b\n", 2])
+      expect(RubyRaider::Schedules::Scheduler).not_to have_received(:new)
+      expect(RubyRaider::Schedules::Legacy).not_to have_received(:new)
+    end
+
+    it 'exits 2 for an argument that is not valid UTF-8, through schedule and sc' do
+      results = [raider('schedule', 'add', "a\xFF", '--every', 'day'), raider('sc', 'remove', "a\xFF")]
+
+      expect(results).to all(eq(['', "Invalid argument \"a\\xFF\": use valid UTF-8\n", 2]))
+      expect(RubyRaider::Schedules::Scheduler).not_to have_received(:new)
+    end
+  end
+
+  describe 'list and remove' do
+    it 'lists as text, or as JSON with --json' do
+      raider('schedule', 'list', '--project', dir)
+      raider('schedule', 'list', '--json', '--project', dir)
+
+      expect(scheduler).to have_received(:list).with(json: false, notice: nil).ordered
+      expect(scheduler).to have_received(:list).with(json: true, notice: nil).ordered
+    end
+
+    it 'removes by name' do
+      raider('schedule', 'remove', 'nightly', '--project', dir)
+
+      expect(scheduler).to have_received(:remove).with('nightly')
+    end
+  end
+
+  describe 'run' do
+    it 'maps run to the wrapper with the manual trigger by default' do
+      _out, _err, code = raider('schedule', 'run', 'nightly', '--project', dir)
+
+      expect(code).to eq(0)
+      expect(wrapper).to have_received(:run).with('nightly', trigger: 'manual')
+      expect(RubyRaider::Schedules::RunWrapper).to have_received(:new).with(project_root)
+    end
+
+    it "exits with the wrapper's code and passes --trigger" do
+      codes = [1, 2, 3].map do |status|
+        allow(wrapper).to receive(:run).and_return(status)
+        raider('sc', 'run', 'nightly', '--trigger', 'schedule', '--project', dir).last
+      end
+
+      expect(codes).to eq([1, 2, 3])
+      expect(wrapper).to have_received(:run).with('nightly', trigger: 'schedule').exactly(3).times
+    end
+
+    it 'exits 2 with one stderr line when the wrapper refuses' do
+      allow(wrapper).to receive(:run).and_raise(RubyRaider::Schedules::Error, 'Invalid trigger "x": use manual or schedule')
+
+      out, err, code = raider('schedule', 'run', 'nightly', '--trigger', 'x', '--project', dir)
+
+      expect([out, err, code]).to eq(['', "Invalid trigger \"x\": use manual or schedule\n", 2])
+    end
+  end
+
+  describe 'the 4.1 cleanup' do # rubocop:disable RSpec/MultipleMemoizedHelpers
+    # Plays the OS scheduler for Legacy: one 4.1 entry of this project, removed or refused
+    let(:fake_adapter_class) do
+      Class.new do
+        attr_reader :ids, :removed
+        attr_accessor :failure
+
+        def initialize(ids)
+          @ids = ids
+          @removed = []
+        end
+
+        def list_ids(prefix) = ids.select { |id| id.start_with?(prefix) }
+
+        def remove(os_id)
+          raise failure if failure
+
+          @removed << os_id
+          true
+        end
+      end
+    end
+    let(:adapter) { fake_adapter_class.new([RubyRaider::Schedules::Legacy::OldRule.os_id_for(dir, 'tredssd')]) }
+    let(:notice) { "Removed 1 schedule made with Ruby Raider 4.1 (tredssd); it can't run in 4.2. Add it again with raider schedule add." }
+
+    before do
+      FileUtils.mkdir_p(File.join(dir, '.raider', 'flows'))
+      allow(RubyRaider::Schedules::Legacy).to receive(:new).and_wrap_original do |original, project|
+        original.call(project, adapter: adapter)
+      end
+    end
+
+    it 'runs before every command, with the project' do
+      allow(RubyRaider::Schedules::Legacy).to receive(:new).and_return(legacy)
+      [%w[add nightly --every day], %w[list], %w[remove nightly], %w[run nightly]].each do |args|
+        raider('schedule', *args, '--project', dir)
+      end
+
+      expect(RubyRaider::Schedules::Legacy).to have_received(:new).with(project_root).exactly(4).times
+      expect(legacy).to have_received(:cleanup).with(no_args).exactly(4).times
+    end
+
+    it 'cleans up before the command runs' do
+      allow(scheduler).to receive(:remove) { expect(adapter.removed.size).to eq(1) }
+
+      raider('schedule', 'remove', 'nightly', '--project', dir)
+
+      expect(scheduler).to have_received(:remove).with('nightly')
+    end
+
+    # The fake keeps listing the entry, so the second list finds it again
+    it 'writes the notice to stderr in text mode, and passes it to the JSON' do
+      _out, err, code = raider('schedule', 'list', '--project', dir)
+      _json_out, json_err, = raider('schedule', 'list', '--json', '--project', dir)
+
+      expect([err, code, json_err]).to eq(["#{notice}\n", nil, "#{notice}\n"])
+      expect(scheduler).to have_received(:list).with(json: false, notice: notice).ordered
+      expect(scheduler).to have_received(:list).with(json: true, notice: notice).ordered
+    end
+
+    it "keeps run's exit code when the cleanup fails" do
+      adapter.failure = RubyRaider::Schedules::Error.new('denied')
+      allow(wrapper).to receive(:run).and_return(1)
+
+      out, err, code = raider('schedule', 'run', 'nightly', '--project', dir)
+
+      expect([out, code]).to eq(['', 1])
+      expect(err).to eq("Could not remove 1 schedule made with Ruby Raider 4.1 (tredssd: denied); it is tried again next time.\n")
+    end
+
+    it 'is skipped, with no adapter, when .raider/flows is not a folder' do
+      allow(RubyRaider::Schedules).to receive(:adapter)
+      FileUtils.rm_rf(File.join(dir, '.raider', 'flows'))
+      outside = File.realpath(Dir.mktmpdir('schedule-commands-outside'))
+      File.symlink(outside, File.join(dir, '.raider', 'flows'))
+      results = [raider('schedule', 'run', 'nightly', '--project', dir)]
+      FileUtils.rm_rf(File.join(dir, '.raider'))
+      results << raider('schedule', 'list', '--project', dir)
+
+      expect(results).to eq([['', '', 0], ['', '', nil]])
+      expect(RubyRaider::Schedules::Legacy).not_to have_received(:new)
+      expect(RubyRaider::Schedules).not_to have_received(:adapter)
+    ensure
+      FileUtils.rm_rf(outside) if outside
+    end
+
+    it 'prints nothing when there is nothing to clean' do
+      adapter.ids.clear
+
+      out, err, code = raider('schedule', 'run', 'nightly', '--project', dir)
+
+      expect([out, err, code]).to eq(['', '', 0])
+    end
+  end
+
+  describe 'help' do
+    it 'lists the four commands in raider help schedule' do
+      out, = raider('help', 'schedule')
+
+      expect(out).to include('schedule add NAME [SPEC_FILE ...]', 'schedule list', 'schedule remove NAME',
+                             'schedule run NAME')
+    end
+
+    # Thor would also reach run_schedule from `run` by prefix; the map is what keeps `run` working if that changes
+    it 'maps run to run_schedule explicitly and shows it as run NAME' do
+      out, = raider('help', 'schedule')
+
+      expect(described_class.map).to include('run' => :run_schedule)
+      expect(out).to match(/^ +\S+ schedule run NAME +# Runs the schedule NAME now/)
+    end
+
+    it 'lists schedule in raider help' do
+      out, = raider('help')
+
+      expect(out).to include('schedule', 'Runs the tests on a schedule')
+    end
+  end
+end

data/spec/integration/content/common_content_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'content_helper'
+require_relative '../../../lib/utilities/schedules/schedule_store'
 
 describe 'Common file content' do
   # --- Rakefile ---
@@ -77,6 +78,10 @@ describe 'Common file content' do
     it 'includes raider-results' do
       expect(gitignore).to include('raider-results')
     end
+
+    it 'ignores .raider/schedules/ with the exact line raider schedule add looks for' do
+      expect(gitignore.lines.map(&:chomp)).to include(RubyRaider::Schedules::ScheduleStore::GITIGNORE_LINE)
+    end
   end
 
   shared_examples 'web gitignore for saved logins' do |project_name|
@@ -89,8 +94,9 @@ describe 'Common file content' do
   end
 
   shared_examples 'mobile gitignore without saved logins' do |project_name|
-    it 'has no .raider line' do
-      expect(read_generated(project_name, '.gitignore')).not_to include('.raider')
+    it 'has no .raider line but .raider/schedules/' do
+      lines = read_generated(project_name, '.gitignore').lines.map(&:strip)
+      expect(lines.grep(/\A\.raider/)).to eq(['.raider/schedules/'])
     end
   end
 

data/spec/integration/content/gemfile_content_spec.rb

@@ -85,8 +85,8 @@ describe 'Gemfile content' do
           expect(gemfile).to include("gem 'ruby_raider', '~> #{major_minor}'")
         end
 
-        it 'pins ruby_raider to the 4.1 release line' do
-          expect(gemfile).to include("gem 'ruby_raider', '~> 4.1'")
+        it 'pins ruby_raider to the 4.2 release line' do
+          expect(gemfile).to include("gem 'ruby_raider', '~> 4.2'")
         end
       end
     end

data/spec/integration/end_to_end_spec.rb

@@ -447,69 +447,6 @@ describe 'End-to-End Project Generation and Execution' do
     end
   end
 
-  # raider flow init and raider flow run on a generated Selenium project, headless, against a local page
-  context 'Flows', :slow do
-    let(:project) { generate_video_project('rspec', 'selenium') }
-
-    def write_flows(project)
-      page = File.join(File.expand_path(project), 'flow_page.html')
-      File.write(page, <<~HTML)
-        <!doctype html><title>Timesheet</title>
-        <label for="hours">Hours</label><input id="hours">
-        <button onclick="document.getElementById('done').textContent = 'Saved ' + document.getElementById('hours').value">Save</button>
-        <p id="done"></p>
-      HTML
-      { 'timesheet' => "driver.find_element(label: 'Hours').send_keys(flow_input('hours', '8'))\n    " \
-                       "driver.find_element(by_role('button', name: 'Save')).click\n    " \
-                       "driver.find_element(text: \"Saved \#{flow_input('hours', '8')}\")",
-        'export' => "driver.find_element(id: 'export').click" }.each do |name, steps|
-        File.write(File.join(project, "flows/#{name}_flow.rb"), <<~RUBY)
-          # frozen_string_literal: true
-
-          require_relative 'flow_helper'
-
-          RSpec.describe '#{name}' do
-            it 'runs' do
-              driver.navigate.to 'file://#{page}'
-              #{steps}
-            end
-          end
-        RUBY
-      end
-    end
-
-    def runs(project, name)
-      File.readlines(File.join(project, ".raider/flows/#{name}/runs.jsonl")).map { |line| JSON.parse(line) }
-    end
-
-    it 'runs a flow headless into flow-results and records completed and failed runs', :aggregate_failures do
-      skip 'Google Chrome is not installed' unless browser_installed?('chrome')
-      FileUtils.rm_rf([File.join(project, 'flows'), File.join(project, '.raider/flows'), File.join(project, 'flow-results')])
-
-      init = run_in_project(project, 'bundle exec raider flow init')
-      expect(init[:exit_code]).to eq(0), init[:stdout] + init[:stderr]
-      write_flows(project)
-      env = { 'VIDEO' => 'off', 'TRACE' => 'off', 'RAIDER_TOKEN' => nil, 'RAIDER_ENDPOINT' => nil }
-      completed = run_in_project(project, 'bundle exec raider flow run timesheet --input hours=7', env:)
-      failed = run_in_project(project, 'bundle exec raider flow run export', env: env.merge('RAIDER_TIMEOUT' => '1'))
-
-      expect(completed[:exit_code]).to eq(0), completed[:stdout] + completed[:stderr]
-      expect(completed[:stdout]).to match(%r{Flow timesheet completed in .* s\nResults: flow-results/timesheet/\d{8}T\d{6}Z})
-      expect(runs(project, 'timesheet').last).to include('status' => 'completed', 'trigger' => 'manual')
-      expect(failed[:exit_code]).to eq(1), failed[:stdout] + failed[:stderr]
-      expect(runs(project, 'export').last).to include('status' => 'failed', 'failed_step' => { 'title' => 'runs', 'line' => 8 })
-      expect(File).to exist(File.join(project, runs(project, 'export').last['results_dir'], 'run.json'))
-      expect(File).not_to exist(File.join(project, 'raider-results'))
-    end
-
-    it 'passes its own RuboCop with the flow files' do
-      FileUtils.rm_rf(File.join(project, 'flows'))
-      run_in_project(project, 'bundle exec raider flow init')
-
-      expect_project_rubocop_clean(project)
-    end
-  end
-
   # Trace replay against headless Chrome, and one example on headless Firefox. The page is served over HTTP from this process (never file://), so
   # WebDriver BiDi reports real network and console entries. raider_reporter ~> 1.0 resolves from RubyGems, or
   # from a checkout at RAIDER_REPORTER_PATH. The example with video on also needs RAIDER_FFMPEG_PATH.