ruby_raider 3.13.0 → 4.0.0

data/sig/vendor/selenium_webdriver.rbs

@@ -0,0 +1,71 @@
+# Minimal Selenium WebDriver stubs for type checking (covers only what Raider's runtime touches)
+module Selenium
+  module WebDriver
+    VERSION: String
+
+    module Error
+      class WebDriverError < StandardError
+      end
+      class ElementNotInteractableError < WebDriverError
+      end
+      class UnsupportedOperationError < WebDriverError
+      end
+      class TimeoutError < WebDriverError
+      end
+      class NoSuchElementError < WebDriverError
+      end
+      class StaleElementReferenceError < WebDriverError
+      end
+    end
+
+    module SearchContext
+      FINDERS: Hash[Symbol, String]
+
+      def self.extra_finders: () -> Hash[Symbol, String]?
+      def self.extra_finders=: (Hash[Symbol, String]?) -> Hash[Symbol, String]?
+      def self.finders: () -> Hash[Symbol, String]
+
+      def bridge: () -> untyped
+      def find_element: (*untyped) -> Element
+      def find_elements: (*untyped) -> Array[Element]
+    end
+
+    class Element
+      include SearchContext
+
+      def initialize: (untyped bridge, String id) -> void
+      def tag_name: () -> String
+      def attribute: (String) -> String?
+      def text: () -> String
+      def displayed?: () -> bool
+      def enabled?: () -> bool
+      def ref: () -> [Symbol, String?]
+      def click: () -> void
+      def send_keys: (*untyped) -> void
+      def clear: () -> void
+      def submit: () -> void
+    end
+
+    class Driver
+      include SearchContext
+
+      def ref: () -> [Symbol, String?]
+    end
+
+    module Remote
+      class Bridge
+        class LocatorConverter
+          def convert: (String | Symbol, untyped) -> [String, untyped]
+        end
+
+        def self.locator_converter: () -> untyped
+        def self.locator_converter=: (untyped) -> untyped
+
+        def find_element_by: (*untyped) -> untyped
+        def find_elements_by: (*untyped) -> untyped
+        def execute_script: (String, *untyped) -> untyped
+        def current_context: () -> String
+      end
+    end
+  end
+end

data/spec/commands/raider_commands_spec.rb

@@ -121,8 +121,8 @@ RSpec.describe RubyRaider::Raider do # rubocop:disable RSpec/FilePath
 
     let(:raider_bin) { File.expand_path('../../bin/raider', __dir__) }
 
-    def run_raider(*args, chdir: Dir.pwd)
-      Open3.capture3(RbConfig.ruby, raider_bin, *args, chdir:)
+    def run_raider(*args, chdir: Dir.pwd, env: {})
+      Open3.capture3(env, RbConfig.ruby, raider_bin, *args, chdir:)
     end
 
     it 'exits non-zero for an unknown command' do
@@ -143,7 +143,8 @@ RSpec.describe RubyRaider::Raider do # rubocop:disable RSpec/FilePath
         out, err, status = run_raider('new', 'x', '-p', 'framework:minitest', 'automation:selenium', chdir: dir)
 
         expect(status.exitstatus).not_to eq(0)
-        expect(out + err).to include('framework', 'rspec', 'cucumber')
+        expect(out + err).to include('framework', 'rspec')
+        expect(out + err).not_to include('cucumber')
         expect(File.exist?(File.join(dir, 'x'))).to be(false)
       end
     end
@@ -167,5 +168,39 @@ RSpec.describe RubyRaider::Raider do # rubocop:disable RSpec/FilePath
         expect(File.exist?(File.join(dir, 'x'))).to be(false)
       end
     end
+
+    it 'exits 1 with the Invalid automation message for automation:watir and creates nothing' do
+      Dir.mktmpdir do |dir|
+        out, err, status = run_raider('new', 'x', '-p', 'framework:rspec', 'automation:watir', chdir: dir)
+
+        expect(status.exitstatus).to eq(1)
+        expect(out + err).to include('Invalid automation "watir"')
+        expect(File.exist?(File.join(dir, 'x'))).to be(false)
+      end
+    end
+
+    describe 'raider new under a US-ASCII locale' do
+      # macOS gives GUI apps no LANG, so a shell spawned by the desktop runs Ruby with a US-ASCII
+      # default_external; the templates hold UTF-8 bytes and must still render. The generated README holds
+      # an ellipsis, so the rendered file proves the bytes came through. RUBYOPT is unset so a
+      # -E or -K flag from the outer environment cannot hide the locale.
+      { 'LC_ALL=C' => { 'LANG' => nil, 'LC_CTYPE' => nil, 'LC_ALL' => 'C', 'RUBYOPT' => nil },
+        'no locale variables' => { 'LANG' => nil, 'LC_CTYPE' => nil, 'LC_ALL' => nil, 'RUBYOPT' => nil } }
+        .each do |label, env|
+        it "renders the config under #{label}" do
+          Dir.mktmpdir do |dir|
+            _out, err, status = run_raider('new', 'x', '-p', 'framework:rspec', 'automation:selenium',
+                                           chdir: dir, env:)
+
+            expect(err).not_to include('invalid multibyte')
+            expect(status.exitstatus).to eq(0)
+            readme = File.read(File.join(dir, 'x/Readme.md'), encoding: 'UTF-8')
+            expect(readme).to include("`expect { account_page.welcome_message }.to have_text(\u2026)`")
+            config = File.read(File.join(dir, 'x/config/config.yml'), encoding: 'UTF-8')
+            expect(YAML.safe_load(config, permitted_classes: [Symbol])['url']).to include('http')
+          end
+        end
+      end
+    end
   end
 end

data/spec/commands/scaffolding_commands_spec.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'open3'
+require 'tmpdir'
+require 'rbconfig'
+require_relative '../../lib/commands/scaffolding_commands'
 
 RSpec.describe 'ScaffoldingCommands' do
   describe 'dependencies' do
@@ -19,4 +22,28 @@ RSpec.describe 'ScaffoldingCommands' do
       expect(stdout.strip).to eq('OK')
     end
   end
+
+  describe 'commands' do
+    it 'has no feature or steps command' do
+      expect(ScaffoldingCommands.all_commands.keys).not_to include('feature', 'steps')
+    end
+  end
+
+  describe 'scaffold in a directory that looks like a Cucumber project' do
+    let(:raider_bin) { File.expand_path('../../bin/raider', __dir__) }
+
+    it 'writes the spec and the page and nothing under features' do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, 'Gemfile'), "gem 'cucumber'\n")
+        FileUtils.mkdir_p(File.join(dir, 'features'))
+
+        _out, err, status = Open3.capture3(RbConfig.ruby, raider_bin, 'g', 'scaffold', 'login', chdir: dir)
+
+        expect(status.success?).to be(true), err
+        expect(File).to exist(File.join(dir, 'spec/login_page_spec.rb'))
+        expect(File).to exist(File.join(dir, 'page_objects/pages/login.rb'))
+        expect(Dir.glob(File.join(dir, 'features/**/*')).select { |f| File.file?(f) }).to be_empty
+      end
+    end
+  end
 end

data/spec/commands/utility_commands_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require_relative '../../lib/ruby_raider'
+
+RSpec.describe UtilityCommands do
+  let(:tmp_dir) { 'tmp_utility_commands_test' }
+
+  before do
+    FileUtils.mkdir_p("#{tmp_dir}/config")
+    Dir.chdir(tmp_dir)
+    File.write('config/config.yml', "browser: chrome\ntimeout: 10\n")
+    Utilities.instance_variable_set(:@config, nil)
+  end
+
+  after do
+    Dir.chdir('..')
+    FileUtils.rm_rf(tmp_dir)
+    Utilities.instance_variable_set(:@config, nil)
+  end
+
+  describe 'strict' do
+    it 'writes strict: false for off' do
+      described_class.new.invoke(:strict, nil, %w[off])
+      expect(YAML.load_file('config/config.yml')['strict']).to be false
+    end
+
+    it 'writes strict: true for on' do
+      described_class.new.invoke(:strict, nil, %w[on])
+      expect(YAML.load_file('config/config.yml')['strict']).to be true
+    end
+  end
+
+  describe 'actionability' do
+    it 'writes actionability: true for on' do
+      described_class.new.invoke(:actionability, nil, %w[on])
+      expect(YAML.load_file('config/config.yml')['actionability']).to be true
+    end
+
+    it 'writes actionability: false for off' do
+      described_class.new.invoke(:actionability, nil, %w[off])
+      expect(YAML.load_file('config/config.yml')['actionability']).to be false
+    end
+  end
+
+  describe 'help' do
+    it 'lists both toggles' do
+      expect { described_class.start(%w[help]) }
+        .to output(%r{actionability \[on/off\].*strict \[on/off\]}m).to_stdout
+    end
+  end
+end

data/spec/generators/gesture_helper_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'tmpdir'
+require_relative '../../lib/generators/helper_generator'
+require_relative '../../lib/ruby_raider/runtime'
+
+# Stands in for the Appium driver: only the calls the gestures make.
+class GestureDriver
+  Rect = Struct.new(:x, :y, :width, :height)
+  Element = Struct.new(:id)
+
+  attr_reader :appium_device
+
+  def initialize(device)
+    @appium_device = device
+  end
+
+  def execute_script(*); end
+
+  def find_element(*); end
+
+  def window_rect
+    Rect.new(0, 10, 400, 800)
+  end
+end
+
+class GesturePage
+  attr_reader :driver
+
+  def initialize(driver)
+    @driver = driver
+  end
+
+  def self.rendered
+    generator = HelpersGenerator.new(%w[ios rspec proj])
+    template = File.expand_path('../../lib/generators/templates/helpers/gesture_helper.tt', __dir__)
+    ERB.new(File.read(template), trim_mode: '-').result(generator.instance_eval { binding })
+  end
+end
+
+Dir.mktmpdir do |dir|
+  path = File.join(dir, 'gesture_helper.rb')
+  File.write(path, GesturePage.rendered)
+  load path
+end
+GesturePage.include(GestureHelper)
+
+describe 'gesture_helper template' do
+  let(:element) { GestureDriver::Element.new('el-1') }
+  let(:driver) { GestureDriver.new(:android) }
+  let(:page) { GesturePage.new(driver) }
+
+  context 'on iOS' do
+    let(:driver) { GestureDriver.new(:ios) }
+
+    it 'swipes the screen with mobile: swipe' do
+      expect(driver).to receive(:execute_script).with('mobile: swipe', { direction: 'left' })
+      page.swipe('left')
+    end
+
+    it 'scrolls an element with mobile: scroll and its id' do
+      expect(driver).to receive(:execute_script).with('mobile: scroll', { direction: 'down', element: 'el-1' })
+      page.scroll(:down, element)
+    end
+  end
+
+  context 'on Android' do
+    let(:driver) { GestureDriver.new(:android) }
+
+    it 'swipes the screen with mobile: swipeGesture over the window rect' do
+      expect(driver).to receive(:execute_script)
+        .with('mobile: swipeGesture', { left: 0, top: 10, width: 400, height: 800, direction: 'up', percent: 0.75 })
+      page.swipe('up')
+    end
+
+    it 'scrolls an element with mobile: scrollGesture and its element id' do
+      expect(driver).to receive(:execute_script)
+        .with('mobile: scrollGesture', { elementId: 'el-1', direction: 'down', percent: 0.75 })
+      page.scroll('down', element)
+    end
+  end
+
+  it 'rejects a direction other than up, down, left or right' do
+    driver = GestureDriver.new(:ios)
+    page = GesturePage.new(driver)
+    expect { page.swipe('diagonal') }.to raise_error(ArgumentError, /direction must be up, down, left or right/)
+  end
+
+  describe '#scroll_to' do
+    let(:locator) { { accessibility_id: 'footer' } }
+
+    let(:driver) { GestureDriver.new(:android) }
+
+    it 'returns the element without scrolling when it is already there' do
+      allow(driver).to receive(:find_element).with(locator).and_return(element)
+      expect(driver).not_to receive(:execute_script)
+      expect(page.scroll_to(locator)).to eq(element)
+    end
+
+    it 'scrolls between tries until the element appears' do
+      attempts = 0
+      immediate = []
+      allow(driver).to receive(:find_element).with(locator) do
+        immediate << Raider::Wait.immediate?
+        attempts += 1
+        raise Selenium::WebDriver::Error::NoSuchElementError, 'gone' if attempts < 3
+
+        element
+      end
+      expect(driver).to receive(:execute_script).twice
+      expect(page.scroll_to(locator, direction: 'up')).to eq(element)
+      expect(immediate).to eq([true, true, true])
+    end
+
+    it 'gives up after max_scrolls and names the locator' do
+      allow(driver).to receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError, 'gone')
+      expect(driver).to receive(:execute_script).exactly(3).times
+      expect { page.scroll_to(locator, max_scrolls: 3) }
+        .to raise_error(Selenium::WebDriver::Error::NoSuchElementError, /accessibility_id.*footer.*after 3 scrolls/)
+    end
+  end
+end