ruby_raider 4.1.0 → 4.2.0

data/sig/utilities/flows/run_log.rbs

@@ -1,22 +0,0 @@
-module RubyRaider
-  module Flows
-    class RunLog
-      MAX_BYTES: Integer
-      NOFOLLOW: Integer
-      NONBLOCK: Integer
-      SUMMARY: Array[String]
-
-      def self.summaries: (Project project) -> Array[Hash[String, untyped]]
-
-      def initialize: (Project project, String name) -> void
-      def lines: () -> Array[Hash[String, untyped]]
-      def last: () -> Hash[String, untyped]?
-      def last_result: () -> Hash[String, untyped]?
-      def find: (String run_id) -> Hash[String, untyped]?
-
-      private
-
-      def tail: () -> String
-    end
-  end
-end

data/sig/utilities/flows/runner.rbs

@@ -1,35 +0,0 @@
-module RubyRaider
-  module Flows
-    class Runner
-      EXIT_CODES: Hash[String, Integer]
-      INPUT: Regexp
-      INPUT_RULE: String
-      TRIGGERS: Array[String]
-      RETRY_WAIT: Integer
-
-      def self.spawn: (Hash[String, String?] env, Array[String] argv, String chdir) -> Integer?
-      def self.stopped: () -> bool?
-      def self.stopped=: (bool) -> bool
-      def self.interrupt: (Integer pid) -> void
-
-      def initialize: (Project project, ?out: IO | StringIO, ?spawner: untyped, ?sleeper: untyped, ?notifier: untyped) -> void
-      def run: (String name, ?headed: bool?, ?retries: untyped, ?inputs: Array[String]?, ?trigger: String, ?notify: bool) -> Integer
-
-      private
-
-      def attempt_runs: (String name, Integer attempts, Hash[Symbol, untyped] options) -> String
-      def notify_failure: (String name, String status, String trigger) -> bool
-      def start_output: (String name, String trigger) -> String
-      def stopped: (String name, String status) -> String
-      def attempt_run: (String name, Integer attempt, Hash[Symbol, untyped] options) -> String
-      def run_env: (String name, Integer attempt, String run_id, Hash[Symbol, untyped] options) -> Hash[String, String?]
-      def input_env: (Array[String]? inputs) -> Hash[String, String]
-      def checked_trigger: (String trigger) -> String
-      def checked_retries: (untyped retries) -> Integer
-      def report: (String name, Hash[String, untyped]? line, Integer? code) -> void
-      def outcome: (Hash[String, untyped] line) -> String
-      def failed_step: (untyped step) -> String
-      def duration: (Hash[String, untyped] line) -> (Float | String)
-    end
-  end
-end

data/spec/commands/flow_commands_spec.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-require 'tmpdir'
-require_relative '../../lib/ruby_raider'
-
-RSpec.describe FlowCommands do
-  let(:raider_bin) { File.expand_path('../../bin/raider', __dir__) }
-
-  def run_raider(*args)
-    Open3.capture3(RbConfig.ruby, raider_bin, *args)
-  end
-
-  it 'lists init, run and list in raider flow help' do
-    out, _err, status = run_raider('flow', 'help')
-
-    expect(status.exitstatus).to eq(0)
-    expect(out).to include('flow init', 'flow run NAME', 'flow list')
-  end
-
-  it 'maps raider f to the flow commands' do
-    out, _err, status = run_raider('f', 'help')
-
-    expect(status.exitstatus).to eq(0)
-    expect(out).to include('flow run NAME')
-  end
-
-  it 'is listed in raider help' do
-    out, = run_raider('help')
-
-    expect(out).to include('raider flow')
-  end
-
-  describe 'init' do
-    it 'sets up flows in the --project folder from any working directory' do
-      Dir.mktmpdir('flow-init') do |dir|
-        File.write(File.join(dir, 'Gemfile'), "gem 'ruby_raider', '~> 4.0'\ngem 'selenium-webdriver'\n")
-        FileUtils.mkdir_p(File.join(dir, 'helpers'))
-        File.write(File.join(dir, 'helpers/driver_helper.rb'), "require 'ruby_raider/runtime'\n")
-
-        out, _err, status = run_raider('flow', 'init', '--project', dir)
-
-        expect(status.exitstatus).to eq(0)
-        expect(out).to include('Created flows/flow_helper.rb', 'Run bundle install')
-      end
-    end
-
-    it 'exits 2 for a project that cannot hold flows' do
-      Dir.mktmpdir('flow-init') do |dir|
-        _out, err, status = run_raider('flow', 'init', '--project', dir)
-
-        expect(status.exitstatus).to eq(2)
-        expect(err).to include('Flows need a Selenium web project made with Ruby Raider 4.0 or later')
-      end
-    end
-
-    it 'exits 2 for a missing project folder' do
-      _out, err, status = run_raider('flow', 'init', '--project', '/nonexistent/raider')
-
-      expect(status.exitstatus).to eq(2)
-      expect(err).to include('Project folder not found')
-    end
-  end
-
-  it 'offers --notify on flow run and flow schedule' do
-    run_help, = run_raider('flow', 'help', 'run')
-    schedule_help, = run_raider('flow', 'help', 'schedule')
-
-    expect([run_help, schedule_help]).to all(include('--notify'))
-  end
-
-  describe 'schedules' do
-    # Only paths refused before the OS scheduler is asked: this machine's launchd is real
-    it 'lists schedule, unschedule and schedules in raider flow help' do
-      out, _err, status = run_raider('flow', 'help')
-
-      expect(status.exitstatus).to eq(0)
-      expect(out).to include('flow schedule NAME', 'flow unschedule NAME', 'flow schedules')
-    end
-
-    it 'dispatches raider flow schedule NAME to schedule, not schedules' do
-      Dir.mktmpdir('flow-schedule') do |dir|
-        _out, err, status = run_raider('flow', 'schedule', 'x', '--every', 'day', '--at', '08:00', '--project', dir)
-
-        expect(status.exitstatus).to eq(2)
-        expect(err).to include('No flow x: flows/x_flow.rb not found')
-      end
-    end
-
-    it 'exits 2 through the rule check when --every is left out' do
-      Dir.mktmpdir('flow-schedule') do |dir|
-        %w[flows/flow_helper.rb flows/support/run.rb flows/report_flow.rb].each do |file|
-          FileUtils.mkdir_p(File.dirname(File.join(dir, file)))
-          File.write(File.join(dir, file), '')
-        end
-        _out, err, status = run_raider('flow', 'schedule', 'report', '--at', '08:00', '--project', dir)
-
-        expect(status.exitstatus).to eq(2)
-        expect(err).to include('Invalid every nil: use hour, day, weekday or week')
-      end
-    end
-
-    it 'exits 2 for an invalid name to unschedule' do
-      Dir.mktmpdir('flow-schedule') do |dir|
-        _out, err, status = run_raider('flow', 'unschedule', 'Bad-Name', '--project', dir)
-
-        expect(status.exitstatus).to eq(2)
-        expect(err).to include('Invalid flow name "Bad-Name"')
-      end
-    end
-
-    it 'exits 2 with a message for an argument that is not valid UTF-8' do
-      _out, err, status = run_raider('flow', 'schedule', "a\xFF".b, '--every', 'day')
-
-      expect(status.exitstatus).to eq(2)
-      expect(err).to eq("Invalid argument \"a\\xFF\": use valid UTF-8\n")
-    end
-
-    it 'says there are no schedules, as text and as JSON' do
-      Dir.mktmpdir('flow-schedule') do |dir|
-        text, = run_raider('flow', 'schedules', '--project', dir)
-        json, = run_raider('flow', 'schedules', '--json', '--project', dir)
-
-        expect([text, json]).to eq(["No schedules yet: raider flow schedule <name> --every day --at 08:00\n", "[]\n"])
-      end
-    end
-  end
-end

data/spec/generators/flow_helper_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'erb'
-
-# The flow templates are copied into projects by `raider flow init`
-RSpec.describe 'flow templates' do
-  let(:templates) { File.expand_path('../../lib/generators/templates', __dir__) }
-  let(:helper) { render('flows/flow_helper.tt') }
-
-  def render(relative) = ERB.new(File.read(File.join(templates, relative)), trim_mode: '-').result
-
-  it 'starts the run before loading spec_helper, so the lock and HEADLESS come before the driver' do
-    expect(helper.index('RaiderFlows::Run.start!')).to be < helper.index("require_relative '../helpers/spec_helper'")
-  end
-
-  it 'sends the report to the flow results folder without cleaning it, even when start! refuses the run' do
-    expect(helper).to match(/begin\n  RaiderFlows::Run.start!\nensure\n  RaiderFlows::Run.configure_reporter\nend/)
-    expect(render('flows/run.tt')).to include('reporter.output_dir = results_dir ||', 'reporter.clean_output_dir = false')
-  end
-
-  it 'never retries a flow inside one run' do
-    expect(helper).to include('config.default_retry_count = 0')
-  end
-
-  it 'marks the start of the steps after spec_helper set up the driver' do
-    expect(helper).to include('config.append_before(:each) { RaiderFlows::Run.steps_started! }')
-  end
-
-  it 'never sets the reporter output folder from spec_helper, so a test run cannot wipe flow results' do
-    spec_helper = File.read(File.join(templates, 'helpers/spec_helper.tt'))
-
-    expect(spec_helper).not_to match(/output_dir|clean_output_dir/)
-  end
-
-  it 'renders Ruby that parses' do
-    [helper, render('flows/run.tt')].each do |source|
-      expect { RubyVM::InstructionSequence.compile(source) }.not_to raise_error
-    end
-  end
-end

data/spec/integration/flows/flow_project.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'erb'
-require 'fileutils'
-
-# A project with the flow files `raider flow init` writes and a stand-in helpers/spec_helper.rb:
-# no browser and no raider_reporter. FAKE_DRIVER_FAIL makes the driver fail in before(:each);
-# FAKE_STEPS writes a run.json whose desktop step map names step 2 of flows/recorded_flow.rb.
-module FlowProject
-  TEMPLATES = File.expand_path('../../../lib/generators/templates/flows', __dir__)
-
-  STUB_SPEC_HELPER = <<~RUBY
-    # frozen_string_literal: true
-
-    require 'json'
-    require 'rspec'
-
-    module RaiderReporter
-      Config = Struct.new(:output_dir, :clean_output_dir)
-      def self.configuration = (@configuration ||= Config.new(output_dir: 'raider-results', clean_output_dir: true))
-      def self.configure = yield(configuration)
-    end
-
-    # What the real reporter would write to and clean, for the specs to read
-    at_exit { File.write('reporter.json', JSON.generate(RaiderReporter.configuration.to_h)) }
-
-    module DriverHelper
-      def driver
-        raise 'the driver could not start' if ENV['FAKE_DRIVER_FAIL']
-
-        @driver ||= Object.new
-      end
-    end
-
-    RSpec.configure do |config|
-      config.include(DriverHelper)
-      config.before(:each) { driver }
-      config.after(:each) { File.write('driver_quit', '') }
-      # The real reporter writes run.json when it closes; the desktop sidecar names the failed step there
-      config.after(:suite) do
-        dir = RaiderReporter.configuration.output_dir
-        steps = { 'items' => [{ 'id' => 's1', 'title' => 'open' }, { 'id' => 's2', 'title' => 'click "Export"' }], 'failed' => 1 }
-        results = [{ 'file_path' => 'flows/recorded_flow.rb', 'status' => 'failed', 'steps' => steps }]
-        File.write(File.join(dir, 'run.json'), JSON.generate('results' => results)) if dir && ENV['FAKE_STEPS']
-      end
-    end
-  RUBY
-
-  module_function
-
-  def build(dir, flows)
-    FileUtils.mkdir_p(File.join(dir, 'flows/support'))
-    FileUtils.mkdir_p(File.join(dir, 'helpers'))
-    File.write(File.join(dir, 'flows/flow_helper.rb'), render('flow_helper.tt'))
-    File.write(File.join(dir, 'flows/support/run.rb'), render('run.tt'))
-    File.write(File.join(dir, 'helpers/spec_helper.rb'), STUB_SPEC_HELPER)
-    File.write(File.join(dir, '.rspec'), "-I .\n--require helpers/spec_helper\n")
-    flows.each { |name, source| File.write(File.join(dir, "flows/#{name}_flow.rb"), source) }
-  end
-
-  def render(name) = ERB.new(File.read(File.join(TEMPLATES, name)), trim_mode: '-').result
-end

data/spec/integration/flows/run_command_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'open3'
-require 'tmpdir'
-require_relative 'flow_project'
-
-# `raider flow run` and `raider flow list` against a project with its own Gemfile, from another folder.
-RSpec.describe 'raider flow run and list' do
-  raider = File.expand_path('../../../bin/raider', __dir__)
-
-  flows = {
-    'ok' => <<~RUBY,
-      require_relative 'flow_helper'
-
-      RSpec.describe 'ok' do
-        it('runs every step') { puts "who=\#{flow_input('who', 'nobody')} headless=\#{ENV.fetch('HEADLESS', 'unset')}" }
-      end
-    RUBY
-    'broken' => <<~RUBY
-      require_relative 'flow_helper'
-
-      RSpec.describe 'broken' do
-        it 'downloads the report' do
-          raise 'no such element'
-        end
-      end
-    RUBY
-  }
-
-  # Built once: bundling the project is the slow part
-  dir = nil
-
-  before(:context) do # rubocop:disable RSpec/BeforeAfterAll
-    dir = File.realpath(Dir.mktmpdir('flow-command'))
-    FlowProject.build(dir, flows)
-    File.write(File.join(dir, 'Gemfile'), "source 'https://rubygems.org'\ngem 'rspec'\n")
-    _out, err, status = Bundler.with_unbundled_env do
-      Open3.capture3('bundle', 'install', '--prefer-local', '--quiet', chdir: dir)
-    end
-    raise "bundle install failed: #{err}" unless status.success?
-  end
-
-  after(:context) { FileUtils.rm_rf(dir) } # rubocop:disable RSpec/BeforeAfterAll
-
-  define_method(:raider_flow) do |*args|
-    out, err, status = Open3.capture3(RbConfig.ruby, raider, 'flow', *args, '--project', dir, chdir: Dir.tmpdir)
-    [out, err, status.exitstatus]
-  end
-
-  it 'runs a completed flow, passing inputs and headless through, and exits 0' do
-    out, _err, code = raider_flow('run', 'ok', '--input', 'who=ada')
-
-    expect(code).to eq(0)
-    expect(out).to include('who=ada headless=true', 'Flow ok completed in ')
-    expect(out).to match(%r{^Results: flow-results/ok/\d{8}T\d{6}Z(-\d+)?$})
-  end
-
-  it 'exits 1 and names the failed line' do
-    out, _err, code = raider_flow('run', 'broken')
-
-    expect(code).to eq(1)
-    expect(out).to include('Flow broken failed at line 5 (downloads the report)')
-  end
-
-  it 'exits 2 for a flow that does not exist' do
-    _out, err, code = raider_flow('run', 'missing')
-
-    expect(code).to eq(2)
-    expect(err).to include('No flow missing: flows/missing_flow.rb not found')
-  end
-
-  it 'lists every flow with its last result as JSON for the desktop' do
-    raider_flow('run', 'ok')
-    out, _err, code = raider_flow('list', '--json')
-    listed = JSON.parse(out)
-
-    expect(code).to eq(0)
-    expect(listed.map { |flow| flow['name'] }).to eq(%w[broken ok])
-    expect(listed.last).to include('file' => 'flows/ok_flow.rb')
-    expect(listed.last['last'].keys).to eq(%w[status finished_at failed_step results_dir])
-    expect(listed.last['last']['status']).to eq('completed')
-  end
-
-  it 'lists flows as text' do
-    raider_flow('run', 'ok')
-    out, = raider_flow('list')
-
-    expect(out).to match(/^ok\s+completed\s+\d{4}-\d\d-\d\dT/)
-  end
-end