ruby_raider 4.1.0 → 4.2.0

data/spec/runtime/retry_reset_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'rbconfig'
+require 'tmpdir'
+
+# Real rspec-retry runs in a subprocess, no browser. The suite mimics a generated project: driver_helper
+# memoises @driver, the after hook quits it, and a quit driver refuses every call like a dead session.
+RSpec.describe 'Retrying a test with a fresh driver' do
+  lib = File.expand_path('../../lib', __dir__)
+
+  suite = <<~'RUBY'
+    require 'json'
+    require 'rspec'
+    require 'rspec/retry' if ENV['RETRY'] == 'before'
+    require 'ruby_raider/runtime/rspec'
+    require 'rspec/retry' if ENV['RETRY'] == 'after'
+
+    LOG = ENV.fetch('LOG')
+    def log(entry) = File.open(LOG, 'a') { |file| file.puts(JSON.generate(entry)) }
+
+    class FakeDriver
+      def quit = @quit = true
+
+      def title
+        raise Errno::ECONNREFUSED, '127.0.0.1:9515' if @quit
+
+        'ok'
+      end
+    end
+
+    module DriverHelper
+      def driver = @driver ||= FakeDriver.new
+    end
+
+    RSpec.configure do |config|
+      config.include(DriverHelper)
+      config.default_retry_count = ENV.fetch('RETRY_COUNT', 0).to_i if config.respond_to?(:default_retry_count=)
+      # A project's own callback: one that resets the driver itself, or one that does not
+      if ENV['OWN_CALLBACK']
+        config.retry_callback = proc do
+          log('callback' => 'project')
+          @driver = nil if ENV['OWN_CALLBACK'] == 'resets'
+        end
+      end
+      config.before(:each) { driver.title }
+      config.after(:each) { driver.quit }
+      config.after(:suite) do
+        callback = config.retry_callback if config.respond_to?(:retry_callback)
+        owner = { Raider::RetryReset::CALLBACK => 'ours', nil => 'none' }.fetch(callback, 'project')
+        log('installed' => config.respond_to?(:retry_callback) ? owner : 'no rspec-retry')
+      end
+    end
+
+    RSpec.describe 'Flaky' do
+      it 'fails on its first try and passes on the next' do
+        tries = File.readlines(LOG).count { |line| line.include?('"try"') } + 1
+        log('try' => tries, 'driver' => driver.object_id)
+        expect(tries).to eq(ENV.fetch('PASS_ON', '2').to_i)
+      end
+    end
+  RUBY
+
+  # The subprocess is a plain ruby, not bundle exec: it finds rspec and rspec-retry through the bundle env
+  # (BUNDLE_GEMFILE, RUBYOPT=-rbundler/setup) it inherits from this rspec run.
+  define_method(:run_suite) do |env|
+    Dir.mktmpdir('raider-retry') do |dir|
+      spec = File.join(dir, 'flaky_spec.rb')
+      log = File.join(dir, 'log.jsonl')
+      File.write(spec, suite)
+      File.write(log, '')
+      out, err, status = Open3.capture3(env.merge('LOG' => log, 'RSPEC_RETRY_RETRY_COUNT' => nil), RbConfig.ruby, '-I', lib,
+                                        '-e', 'require "rspec/core"; exit RSpec::Core::Runner.run(ARGV)', spec, chdir: dir)
+      { status: status.exitstatus, output: out + err, log: File.readlines(log).map { |line| JSON.parse(line) } }
+    end
+  end
+
+  define_method(:tries) { |result| result[:log].select { |entry| entry.key?('try') } }
+  define_method(:installed) { |result| result[:log].find { |entry| entry.key?('installed') }&.fetch('installed') }
+
+  %w[before after].each do |order|
+    it "passes on the second try with a fresh driver when rspec/retry is required #{order} the runtime" do
+      result = run_suite('RETRY' => order, 'RETRY_COUNT' => '2')
+      expect([result[:status], tries(result).map { |entry| entry['try'] }]).to eq([0, [1, 2]]), result[:output]
+      expect(tries(result).map { |entry| entry['driver'] }.uniq.size).to eq(2)
+      expect(installed(result)).to eq('ours')
+    end
+  end
+
+  it 'keeps a retry_callback the project set' do
+    result = run_suite('RETRY' => 'before', 'RETRY_COUNT' => '2', 'OWN_CALLBACK' => 'resets')
+    expect([result[:status], installed(result)]).to eq([0, 'project']), result[:output]
+    expect(result[:log]).to include({ 'callback' => 'project' })
+  end
+
+  it 'a project callback that keeps the driver still fails on the quit session' do
+    result = run_suite('RETRY' => 'before', 'RETRY_COUNT' => '2', 'OWN_CALLBACK' => 'keeps')
+    expect([result[:status], installed(result), tries(result).size]).to eq([1, 'project', 1])
+    expect(result[:output]).to include('Errno::ECONNREFUSED')
+  end
+
+  it 'changes nothing when no retry happens' do
+    result = run_suite('RETRY' => 'before', 'RETRY_COUNT' => '2', 'PASS_ON' => '1')
+    expect([result[:status], tries(result).size, installed(result)]).to eq([0, 1, 'ours']), result[:output]
+  end
+
+  it 'does nothing without rspec-retry' do
+    result = run_suite('PASS_ON' => '1')
+    expect([result[:status], installed(result)]).to eq([0, 'no rspec-retry']), result[:output]
+  end
+end

data/spec/runtime/show_browser_project_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'open3'
+require 'rbconfig'
+require 'rspec'
+require 'tmpdir'
+
+# A Selenium project generated by this branch (its helper templates are byte-identical to 4.0.1's) with
+# `headless: true` in config/config.yml. Its own helpers/driver_helper.rb builds the browser options, no
+# browser is started. RAIDER_SHOW_BROWSER=1 drops the --headless it adds; config.yml is never written.
+RSpec.describe 'Show the browser in a generated project', :slow do
+  lib = File.expand_path('../../lib', __dir__)
+
+  generate = <<~RUBY
+    require 'generators/invoke_generators'
+    InvokeGenerators.generate_framework(automation: 'selenium', framework: 'rspec', name: 'shown', examples: false)
+  RUBY
+
+  # Loads the project's real driver_helper and prints the args of the options it builds
+  options = <<~RUBY
+    require 'json'
+    require './helpers/driver_helper'
+    helper = Object.new.extend(DriverHelper)
+    helper.instance_variable_set(:@config, YAML.load_file('config/config.yml'))
+    built = helper.send(:create_webdriver_options)
+    puts JSON.generate(built.as_json.fetch(built.class::KEY).fetch('args'))
+  RUBY
+
+  define_method(:ruby) do |env, dir, script|
+    out, err, status = Open3.capture3(env, RbConfig.ruby, '-I', lib, '-e', script, chdir: dir)
+    raise "ruby failed in #{dir}: #{err}" unless status.success?
+
+    out
+  end
+
+  # rubocop:disable RSpec/InstanceVariable
+  before(:all) do # rubocop:disable RSpec/BeforeAfterAll
+    @tmp = Dir.mktmpdir('raider-show-browser')
+    ruby({}, @tmp, generate)
+    @project = File.join(@tmp, 'shown')
+    config = File.join(@project, 'config', 'config.yml')
+    File.write(config, "#{File.read(config)}headless: true\n")
+    @before = File.binread(config)
+    @args = { off: { 'RAIDER_SHOW_BROWSER' => nil, 'HEADLESS' => nil }, shown: { 'RAIDER_SHOW_BROWSER' => '1', 'HEADLESS' => nil },
+              shown_hidden_env: { 'RAIDER_SHOW_BROWSER' => '1', 'HEADLESS' => 'true' }, other: { 'RAIDER_SHOW_BROWSER' => 'true', 'HEADLESS' => nil } }
+            .transform_values { |env| JSON.parse(ruby(env, @project, options)) }
+  end
+
+  after(:all) { FileUtils.rm_rf(@tmp) } # rubocop:disable RSpec/BeforeAfterAll
+
+  it 'requires the runtime from the generated driver_helper' do
+    expect(File.read(File.join(@project, 'helpers', 'driver_helper.rb'))).to include("require 'ruby_raider/runtime'")
+  end
+
+  it 'keeps --headless without RAIDER_SHOW_BROWSER=1' do
+    expect(@args.values_at(:off, :other)).to all(include('--headless'))
+  end
+
+  it 'drops --headless with RAIDER_SHOW_BROWSER=1, even with HEADLESS set, and keeps the browser arguments' do
+    expected = @args[:off] - ['--headless']
+    expect(@args.values_at(:shown, :shown_hidden_env)).to eq([expected, expected])
+  end
+
+  it 'never writes config.yml' do
+    expect(File.binread(File.join(@project, 'config', 'config.yml'))).to eq(@before)
+  end
+  # rubocop:enable RSpec/InstanceVariable
+end

data/spec/runtime/show_browser_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'rbconfig'
+require 'rspec'
+require_relative '../../lib/ruby_raider/runtime/show_browser'
+
+# The prepend is process-wide, so every case that loads the runtime and looks at the Options classes runs
+# in its own ruby with an explicit RAIDER_SHOW_BROWSER. This process only checks the pure helpers.
+RSpec.describe Raider::ShowBrowser do # rubocop:disable RSpec/FilePath
+  lib = File.expand_path('../../lib', __dir__)
+
+  # Loads the runtime the way a project's driver_helper does, then reports the real Options classes
+  probe = <<~RUBY
+    require 'json'
+    require 'ruby_raider/runtime'
+    filter = Raider::ShowBrowser::Filter
+    Raider::ShowBrowser.install(ENV) if ARGV.include?('again')
+    report = %w[Chrome Edge Firefox].to_h do |browser|
+      klass = Selenium::WebDriver.const_get(browser)::Options
+      built = klass.new(args: ['--headless', 'start-maximized', '--headless=new', '-headless'])
+      %w[--headless --headless=old -headless window-size=800,600 --headlessly headless].each { |arg| built.add_argument(arg) }
+      set = klass.new
+      set.args = ['--headless', 'set']
+      keyed = klass.new('args' => ['-headless', 'keyed'])
+      args = ->(options) { options.as_json.fetch(klass::KEY).fetch('args') }
+      added = klass.new
+      returned = [added.add_argument('--headless'), added.add_argument('kept')].map { |value| value.equal?(added.options[:args]) }
+      [browser, { 'prepended' => klass.ancestors.count(filter), 'built' => args.call(built), 'set' => args.call(set),
+                  'keyed' => keyed.options['args'], 'returned' => returned }]
+    end
+    puts JSON.generate(report)
+  RUBY
+
+  define_method(:probe) do |value, *argv|
+    out, err, status = Open3.capture3({ 'RAIDER_SHOW_BROWSER' => value, 'HEADLESS' => nil }, RbConfig.ruby, '-I', lib, '-e', probe, *argv)
+    raise "probe failed: #{err}" unless status.success?
+
+    JSON.parse(out)
+  end
+
+  context 'with RAIDER_SHOW_BROWSER=1' do
+    let(:report) { probe('1') }
+
+    it 'prepends the filter once to the Chrome, Edge and Firefox options' do
+      expect(report.transform_values { |browser| browser['prepended'] }).to eq('Chrome' => 1, 'Edge' => 1, 'Firefox' => 1)
+    end
+
+    it 'prepends it once when installed again' do
+      expect(probe('1', 'again').transform_values { |browser| browser['prepended'] }).to eq('Chrome' => 1, 'Edge' => 1, 'Firefox' => 1)
+    end
+
+    it 'drops --headless, --headless=* and -headless from args: and add_argument and keeps every other argument' do
+      expected = %w[start-maximized window-size=800,600 --headlessly headless]
+      expect(report.transform_values { |browser| browser['built'] }).to eq('Chrome' => expected, 'Edge' => expected, 'Firefox' => expected)
+    end
+
+    it 'returns the args from add_argument as Selenium does, also for a dropped switch' do
+      expect(report.transform_values { |browser| browser['returned'] }).to eq('Chrome' => [true, true], 'Edge' => [true, true], 'Firefox' => [true, true])
+    end
+
+    it 'drops them from args= and from a string args key' do
+      expect(report.transform_values { |browser| browser.values_at('set', 'keyed') })
+        .to eq('Chrome' => [%w[set], %w[keyed]], 'Edge' => [%w[set], %w[keyed]], 'Firefox' => [%w[set], %w[keyed]])
+    end
+  end
+
+  [nil, '', '0', 'true', '1 ', 'yes'].each do |value|
+    it "prepends nothing and keeps --headless when RAIDER_SHOW_BROWSER is #{value.inspect}" do
+      report = probe(value)
+      expect(report.transform_values { |browser| [browser['prepended'], browser['built'].first, browser['set']] })
+        .to eq('Chrome' => [0, '--headless', %w[--headless set]], 'Edge' => [0, '--headless', %w[--headless set]],
+               'Firefox' => [0, '--headless', %w[--headless set]])
+    end
+  end
+
+  describe '.headless?' do
+    it 'matches only the headless switches' do
+      args = ['--headless', '--headless=new', '--headless=', '-headless', 'headless', '--headlessly', '-headless=new', ' --headless', :'--headless', nil]
+      expect(args.select { |arg| described_class.headless?(arg) }).to eq(['--headless', '--headless=new', '--headless=', '-headless'])
+    end
+  end
+
+  describe '.without_headless' do
+    it 'returns a new array and leaves the given one untouched' do
+      given = %w[--headless keep].freeze
+      expect(described_class.without_headless(given)).to eq(%w[keep])
+    end
+
+    it 'passes anything that is not an array through' do
+      expect([nil, '--headless'].map { |value| described_class.without_headless(value) }).to eq([nil, '--headless'])
+    end
+  end
+
+  describe '.install' do
+    it 'installs nothing unless the value is exactly 1' do
+      expect([{}, { 'RAIDER_SHOW_BROWSER' => 'true' }].map { |env| described_class.install(env) }).to eq([[], []])
+    end
+  end
+end

data/spec/utilities/schedules/kind_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/utilities/schedules/kind'
+
+RSpec.describe RubyRaider::Schedules::Kind do # rubocop:disable RSpec/FilePath
+  let(:kind) { described_class::FLOW_LEGACY }
+  let(:os_id) { 'dev.rubyraider.flow.0123456789.report' }
+
+  it 'keeps the 4.1 words in its OS entries and says 4.1 schedule to the user' do
+    expect([kind.os_id_prefix, kind.cron_tag, kind.dir, kind.task_file_prefix, kind.service_description('report'),
+            kind.timer_description('report'), kind.task_description('report', 'every day at 08:00'), kind.not_ours,
+            kind.unsupported('solaris')])
+      .to eq(['dev.rubyraider.flow', '# raider-flow ', '.raider/flows', 'raider-flow-task', 'raider flow report',
+              'raider flow report schedule', 'Ruby Raider flow report (every day at 08:00)', 'not a 4.1 schedule',
+              'Scheduling 4.1 schedules is not supported on solaris'])
+  end
+
+  it 'names raider schedule list, with no name, for a stranded timer' do
+    expect(kind.stranded('report'))
+      .to eq('This schedule is a systemd timer; run raider schedule list from a session where systemctl --user works')
+  end
+
+  it 'says no flow word to the user' do
+    expect([kind.noun, kind.plural, kind.remove_command, kind.not_ours, kind.stranded('report'), kind.unsupported('solaris')])
+      .to all(satisfy { |text| !text.match?(/\bflows?\b/i) })
+  end
+
+  it 'reads the name from an os_id of its own kind only' do
+    expect([kind.name_in(os_id), kind.name_in('dev.rubyraider.schedule.0123456789.report'), kind.name_in("#{os_id}\n"),
+            kind.name_in('dev.rubyraider.flow.0123456789.env'), kind.name_in(nil)]).to eq(['report', nil, nil, nil, nil])
+  end
+
+  it 'reserves env for flows while Schedules does not' do
+    expect([kind.valid_name?('env'), RubyRaider::Schedules.valid_name?('env'), kind.valid_name?('a' * 61)]).to eq([false, true, false])
+  end
+
+  it 'knows its own command line under a cron tag' do
+    line = '0 8 * * * cd /p && /usr/bin/env /r /b exec raider flow run report --project /p --trigger schedule >> /l 2>&1'
+    expect([kind.our_command?(line, 'report'), kind.our_command?(line, 'other')]).to eq([true, false])
+  end
+
+  it 'is frozen' do
+    expect([kind, kind.os_id_prefix, kind.reserved]).to all(be_frozen)
+  end
+
+  describe 'TESTS' do
+    let(:tests) { described_class::TESTS }
+
+    it 'names test schedules with the schedule words' do
+      expect([tests.os_id_prefix, tests.cron_tag, tests.dir, tests.service_description('nightly'), tests.timer_description('nightly'),
+              tests.task_description('nightly', 'every day at 08:00'), tests.not_ours, tests.unsupported('solaris')])
+        .to eq(['dev.rubyraider.schedule', '# raider-schedule ', '.raider/schedules', 'raider schedule nightly',
+                'raider schedule nightly schedule', 'Ruby Raider schedule nightly (every day at 08:00)', 'not a test schedule',
+                'Scheduling tests is not supported on solaris'])
+    end
+
+    it 'names raider schedule remove for a stranded timer' do
+      expect(tests.stranded('nightly'))
+        .to eq('This schedule is a systemd timer; run raider schedule remove nightly from a session where systemctl --user works')
+    end
+
+    it 'reserves no name and reads only its own os_ids' do
+      expect([tests.valid_name?('env'), tests.name_in('dev.rubyraider.schedule.0123456789.env'), tests.name_in(os_id)]).to eq([true, 'env', nil])
+    end
+
+    it 'reads no os_id from text that is not valid UTF-8, and lists only ids under the prefix' do
+      prefix = 'dev.rubyraider.schedule.0123456789.'
+      broken = "#{prefix}a\xFF".dup.force_encoding(Encoding::UTF_8)
+
+      expect([tests.name_in(broken), tests.listed?(broken, prefix), tests.listed?("#{prefix}nightly", prefix),
+              tests.listed?("#{prefix}nightly", 'dev.rubyraider.schedule.9999999999.'), tests.listed?(nil, prefix)])
+        .to eq([nil, false, true, false, false])
+    end
+
+    it 'knows its own command line under a cron tag, not a flow one' do
+      line = '0 8 * * * cd /p && /usr/bin/env /r /b exec raider schedule run nightly --project /p --trigger schedule >> /l 2>&1'
+      expect([tests.our_command?(line, 'nightly'), kind.our_command?(line, 'nightly'), tests.our_command?(line.sub(' --trigger schedule', ''), 'nightly')])
+        .to eq([true, false, false])
+    end
+  end
+end