ruby_raider 3.13.0 → 4.0.0

data/spec/integration/content/cucumber_reporter_content_spec.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'content_helper'
-
-describe 'Cucumber raider_reporter wiring' do
-  screenshot_calls = {
-    'selenium' => 'driver.save_screenshot(screenshot_path)',
-    'watir' => 'browser.screenshot.save(screenshot_path)'
-  }
-
-  AUTOMATION_TYPES.each do |automation|
-    context "with cucumber and #{automation}" do
-      let(:project_name) { "#{FrameworkIndex::CUCUMBER}_#{automation}" }
-      let(:env) { read_generated(project_name, 'features/support/env.rb') }
-      let(:screenshot_call) { screenshot_calls.fetch(automation, 'driver.screenshot(screenshot_path)') }
-      let(:hook) { env[/^\s*After do.*\z/m] }
-      let(:quit_call) { automation == 'watir' ? 'browser.quit' : 'driver.quit' }
-
-      it 'activates the reporter by requiring raider_reporter/cucumber' do
-        expect(env).to include("require 'raider_reporter/cucumber'")
-      end
-
-      it 'does not reference the allure helper' do
-        expect(env).not_to match(/AllureHelper|allure_helper/)
-      end
-
-      it 'takes the screenshot only for failed scenarios, inside the guard block' do
-        guarded = /if scenario\.failed\?\n\s+Dir\.mktmpdir do \|temp_folder\|\n(?<body>.*?)\n\s+end\n\s+end\nensure/m
-        expect(hook.match(guarded)[:body]).to include(screenshot_call)
-      end
-
-      it 'uses a fixed file name in the tmpdir, never the scenario name' do
-        expect(env).to include("screenshot_path = File.join(temp_folder, 'screenshot.png')")
-        expect(hook).not_to include('scenario.name')
-      end
-
-      it 'quits the driver in an ensure of the After block, without a redundant begin' do
-        quit = %w[android ios cross_platform].include?(automation) ? 'driver.quit_driver' : quit_call
-        expect(hook).to match(/^\s*After do \|scenario\|\n.*\n^ensure\n.*\n\s+#{Regexp.escape(quit)}\nend/m)
-        expect(hook).not_to match(/^\s+begin$/)
-      end
-
-      it 'attaches the screenshot path before quitting the driver' do
-        attach = "RaiderReporter.attach('screenshot', screenshot_path, type: :png)"
-        expect(env).to include(attach)
-        expect(env.index(screenshot_call)).to be < env.index(attach)
-        expect(env.index(attach)).to be < env.index(/driver\.quit|browser\.quit/, env.index(attach))
-      end
-
-      context 'with video recording' do
-        target = automation == 'watir' ? 'browser' : 'driver'
-        video_type = %w[selenium watir].include?(automation) ? ':webm' : ':mp4'
-
-        it 'requires video_helper' do
-          expect(env).to include("require_relative '../../helpers/video_helper'")
-        end
-
-        it 'starts the recorder in Before' do
-          expect(env[/^Before do.*?^end$/m]).to include("@video_recorder = VideoHelper.recorder_for(#{target})", '@video_recorder.start')
-        end
-
-        it 'stops with keep: scenario.failed? before quitting, attaches the path and cleans up in the ensure' do
-          expect(hook).to include('video_path = @video_recorder&.stop(keep: scenario.failed?)')
-          expect(hook).to include("RaiderReporter.attach('video', video_path, type: #{video_type}) if video_path")
-          expect(hook.index('@video_recorder&.stop')).to be < hook.index("RaiderReporter.attach('video'")
-          expect(hook.index("RaiderReporter.attach('video'")).to be < hook.index(/^ensure/)
-          expect(hook.index(/^ensure/)).to be < hook.index('@video_recorder&.cleanup')
-        end
-      end
-
-      if automation == 'selenium'
-        context 'with trace recording' do
-          it 'requires trace_helper' do
-            expect(env).to include("require_relative '../../helpers/trace_helper'")
-          end
-
-          it 'counts attempts per scenario location and starts the trace recorder after the video recorder' do
-            before_hook = env[/^Before do.*?^end$/m]
-            expect(env).to match(/^TRACE_ATTEMPTS = Hash\.new\(0\) unless defined\?\(TRACE_ATTEMPTS\)$/)
-            expect(before_hook).to include('TRACE_ATTEMPTS[scenario.location.to_s] += 1', '@trace_recorder = TraceHelper.recorder_for(driver)')
-            expect(before_hook).to match(/^Before do \|scenario\|$/)
-            expect(before_hook.index('@video_recorder.start')).to be < before_hook.index('@trace_recorder = TraceHelper')
-            expect(before_hook).to match(/if defined\?\(TraceHelper\)\n(.*\n)*.*@trace_recorder = TraceHelper/)
-          end
-
-          it 'stops with keep: TraceHelper.keep_all? || scenario.failed? before the video, attaches it and cleans up before quitting' do
-            expect(hook).to include('TraceHelper.keep_all? || scenario.failed?', 'error: scenario.exception', 'attempt: @trace_attempt')
-            expect(hook).to include("RaiderReporter.attach('trace', trace_path, type: :trace, attempt: @trace_attempt) if trace_path")
-            order = [hook.index('@trace_recorder&.stop'), hook.index('@video_recorder&.stop'), hook.index("RaiderReporter.attach('trace'"),
-                     hook.index(/^ensure/), hook.index('@trace_recorder&.cleanup'), hook.index('@video_recorder&.cleanup'), hook.index('driver.quit')]
-            expect(order).to all(be_an(Integer)).and eq(order.compact.sort)
-          end
-
-          it 'survives a Before that raised before the trace init, and a failing plugin setup or handler' do
-            expect(hook).to include('@trace_test&.merge(')
-            expect(hook).not_to include('@trace_test.merge(')
-            plugin = env[/^InstallPlugin do.*?^end$/m]
-            expect(plugin.scan('rescue StandardError => e').size).to eq(3)
-            expect(plugin.index('AstLookup.new')).to be > plugin.index("begin\n")
-            expect(plugin).to include('TraceHelper.warn_once("Gherkin step groups unavailable')
-          end
-
-          it 'turns tracing off with TraceHelper.disable! when a step group handler raises' do
-            plugin = env[/^InstallPlugin do.*?^end$/m]
-            expect(plugin.scan(/TraceHelper\.disable!\("step groups failed: \#\{e\.message\}"\) if defined\?\(TraceHelper\)/).size).to eq(2)
-            expect(plugin).not_to include('tracing disabled')
-          end
-
-          it 'records each Gherkin step as a group through the InstallPlugin step events, skipping hooks' do
-            plugin = env[/^InstallPlugin do.*?^end$/m]
-            expect(plugin).to include('config.on_event(:test_step_started)', 'config.on_event(:test_step_finished)', 'next if event.test_step.hook?')
-            expect(plugin).to include('TraceHelper.active_recorder&.step_started', 'TraceHelper.active_recorder&.step_finished')
-            expect(plugin).to include('defined?(TraceHelper)')
-          end
-        end
-      else
-        it 'has no trace wiring' do
-          expect(env).not_to match(/trace/i)
-        end
-      end
-
-      it 'does not generate the allure helper' do
-        expect(File).not_to exist(File.join(project_name, 'helpers/allure_helper.rb'))
-      end
-
-      it 'does not mention Allure in any generated file' do
-        files = Dir.glob("#{project_name}/**/*", File::FNM_DOTMATCH).select { |f| File.file?(f) }
-        expect(files.select { |f| File.read(f).match?(/allure/i) }).to be_empty
-      end
-
-      it 'does not create an allure-results folder' do
-        expect(File).not_to exist(File.join(project_name, 'allure-results'))
-      end
-    end
-  end
-end
-
-describe 'Cucumber login reuse wiring' do
-  { 'selenium' => 'driver', 'watir' => 'browser.driver' }.each do |automation, target|
-    context "with cucumber and #{automation}" do
-      let(:env) { read_generated("#{FrameworkIndex::CUCUMBER}_#{automation}", 'features/support/env.rb') }
-
-      it 'requires session_state' do
-        expect(env).to include("require_relative '../../helpers/session_state'")
-      end
-
-      it "reuses the saved login in Before('@logged_in'), defined after the plain Before" do
-        expect(env).to include("Before('@logged_in') do", "SessionState.new(#{target}).reuse(",
-                               "UserFactory.for('registered user')")
-        expect(env.index("Before('@logged_in')")).to be > env.index(/^Before do/)
-      end
-    end
-  end
-
-  %w[android ios cross_platform].each do |automation|
-    it "does not mention session_state with cucumber and #{automation}" do
-      env = read_generated("#{FrameworkIndex::CUCUMBER}_#{automation}", 'features/support/env.rb')
-      expect(env).not_to include('session_state')
-    end
-  end
-end

data/spec/integration/generators/cucumber_generator_spec.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../lib/generators/cucumber/cucumber_generator'
-require_relative '../spec_helper'
-
-describe CucumberGenerator do
-  shared_examples 'creates cucumber files' do |project_name, file_name|
-    it 'creates a feature file' do
-      expect(File).to exist("#{project_name}/features/#{file_name}.feature")
-    end
-
-    it 'creates a step definitions file' do
-      expect(File).to exist("#{project_name}/features/step_definitions/#{file_name}_steps.rb")
-    end
-
-    it 'creates an env file' do
-      expect(File).to exist("#{project_name}/features/support/env.rb")
-    end
-
-    it 'creates an cucumber.yml file' do
-      expect(File).to exist("#{project_name}/cucumber.yml")
-    end
-
-    it 'does not create a spec file' do
-      expect(File).not_to exist("#{project_name}/spec/home_spec.rb")
-    end
-  end
-
-  shared_examples 'creates factories for web projects' do |project_name|
-    it 'creates an data file' do
-      expect(File).to exist("#{project_name}/models/data/users.yml")
-    end
-
-    it 'creates a model factory' do
-      expect(File).to exist("#{project_name}/models/model_factory.rb")
-    end
-
-    it 'creates a user factory' do
-      expect(File).to exist("#{project_name}/models/user_factory.rb")
-    end
-  end
-
-  context 'with cucumber and appium android' do
-    include_examples 'creates cucumber files', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}", 'home'
-  end
-
-  context 'with cucumber and appium ios' do
-    include_examples 'creates cucumber files', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}", 'home'
-  end
-
-  context 'with cucumber and appium cross platform' do
-    include_examples 'creates cucumber files', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}", 'home'
-  end
-
-  context 'with cucumber and selenium' do
-    include_examples 'creates cucumber files', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}", 'login'
-    include_examples 'creates factories for web projects', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}", 'login'
-  end
-
-  context 'with cucumber and watir' do
-    include_examples 'creates cucumber files', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}", 'login'
-    include_examples 'creates factories for web projects', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}", 'login'
-  end
-
-  describe 'without example tests' do
-    %w[selenium ios cross_platform].each do |automation|
-      context "with cucumber and #{automation}" do
-        let(:name) { ensure_project(framework: 'cucumber', automation:, examples: false) }
-
-        it 'creates no feature files' do
-          expect(Dir.glob("#{name}/features/**/*.feature")).to be_empty
-        end
-
-        it 'keeps an empty step_definitions folder' do
-          expect(Dir.children("#{name}/features/step_definitions")).to eq(['.keep'])
-        end
-
-        it 'creates the support files' do
-          expect(Dir.children("#{name}/features/support")).to contain_exactly('env.rb', 'world.rb')
-        end
-
-        it 'creates the cucumber.yml file' do
-          expect(File).to exist("#{name}/cucumber.yml")
-        end
-
-        it 'creates no user factory' do
-          expect(File).not_to exist("#{name}/models/user_factory.rb")
-        end
-      end
-    end
-
-    it 'creates no accessibility example' do
-      InvokeGenerators.generate_framework(framework: 'cucumber', automation: 'selenium', name: 'skeleton_axe_cucumber',
-                                          examples: false, accessibility: true)
-      expect(Dir.glob('skeleton_axe_cucumber/features/**/accessibility*')).to be_empty
-    ensure
-      FileUtils.rm_rf('skeleton_axe_cucumber')
-    end
-  end
-end

data/spec/integration/helpers/wait_helper_mobile_spec.rb

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'wait_helper_support'
-
-# The mobile render loads into App, so its WaitHelper and RaiderElement never meet the web
-# render's top-level ones when both spec files run in one process.
-module WaitHelperMobileSpec
-  module App; end
-  WaitHelperSpec.load_templates(mobile: true, into: App)
-
-  class Page
-    include App::WaitHelper
-
-    attr_reader :driver
-
-    def initialize(driver)
-      @driver = driver
-    end
-  end
-
-  RSpec.describe 'WaitHelper on mobile' do
-    let(:driver) { WaitHelperSpec::FakeDriver.new(device: :ios) }
-    let(:android) { WaitHelperSpec::FakeDriver.new(device: :android) }
-    let(:page) { Page.new(driver) }
-    let(:per_os) { { ios: { accessibility_id: 'ios-card' }, android: { accessibility_id: 'android-card' } } }
-
-    def element(**state) = WaitHelperSpec::FakeElement.new(**state)
-    def clock = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    def screen_area = { left: 0, top: 20, width: 390, height: 800 }
-
-    describe '#tap and #click' do
-      it 'click once the element is visible, enabled and stable' do
-        %i[tap click].each do |name|
-          target = element(rects: [[0, 0, 10, 10], [5, 5, 10, 10], [5, 5, 10, 10]])
-          driver.script({ accessibility_id: name.to_s }, nil, element(displayed: false), element(enabled: false), target)
-          expect(page.public_send(name, { accessibility_id: name.to_s }, timeout: 2)).to eq(target)
-          expect(target.log).to eq([[:click]])
-        end
-      end
-    end
-
-    describe 'tap with a block' do
-      it 'is Object#tap on a RaiderElement: yields and returns the wrapper without clicking' do
-        card = element
-        driver.script({ accessibility_id: 'card' }, card)
-        wrapper = page.find_element(accessibility_id: 'card')
-        seen = nil
-        expect(wrapper.tap { |yielded| seen = yielded }).to be(wrapper)
-        expect([seen, card.log]).to eq([wrapper, []])
-      end
-
-      it 'is Object#tap on the mixin: yields self without looking anything up' do
-        seen = nil
-        expect(page.tap { |yielded| seen = yielded }).to be(page)
-        expect(page.tap(&:driver)).to be(page)
-        expect([seen, driver.finds, driver.scripts]).to eq([page, [], []])
-      end
-
-      it 'still clicks without a block' do
-        card = element
-        driver.script({ id: 'x' }, card)
-        page.tap({ id: 'x' }, timeout: 1)
-        page.tap(id: 'x')
-        page.find_element(id: 'x').tap
-        expect(card.log).to eq([[:click]] * 3)
-      end
-    end
-
-    describe '#swipe' do
-      it 'uses mobile: swipe on iOS' do
-        card = element
-        driver.script({ accessibility_id: 'card' }, card)
-        expect(page.swipe('left', { accessibility_id: 'card' }, timeout: 1)).to eq(card)
-        expect(driver.scripts).to eq([['mobile: swipe', { direction: 'left', element: card.id }]])
-      end
-
-      it 'uses mobile: swipeGesture on Android' do
-        card = element
-        android.script({ accessibility_id: 'card' }, card)
-        Page.new(android).swipe('left', { accessibility_id: 'card' }, timeout: 1)
-        expect(android.scripts)
-          .to eq([['mobile: swipeGesture', { elementId: card.id, direction: 'left', percent: 0.75 }]])
-      end
-
-      it 'waits for the element to be visible first' do
-        card = element
-        driver.script({ accessibility_id: 'card' }, nil, element(displayed: false), card)
-        page.swipe('up', { accessibility_id: 'card' }, timeout: 1)
-        expect([driver.finds.size, driver.scripts.size]).to eq([3, 1])
-      end
-
-      it 'swipes the whole screen without a locator' do
-        expect(page.swipe('up')).to be_nil
-        Page.new(android).swipe('up')
-        expect(driver.scripts).to eq([['mobile: swipe', { direction: 'up' }]])
-        expect(android.scripts).to eq([['mobile: swipeGesture', { **screen_area, direction: 'up', percent: 0.75 }]])
-      end
-
-      it 'rejects a direction other than up, down, left or right' do
-        expect { page.swipe('sideways') }.to raise_error(ArgumentError, /up, down, left or right/)
-        expect(driver.scripts).to be_empty
-      end
-    end
-
-    describe '#scroll' do
-      it 'scrolls the screen without a locator' do
-        page.scroll('down')
-        Page.new(android).scroll('down')
-        expect(driver.scripts).to eq([['mobile: scroll', { direction: 'down' }]])
-        expect(android.scripts).to eq([['mobile: scrollGesture', { **screen_area, direction: 'down', percent: 0.75 }]])
-      end
-
-      it 'scrolls a container' do
-        list = element
-        android.script({ id: 'list' }, list)
-        Page.new(android).scroll('up', { id: 'list' }, timeout: 1)
-        expect(android.scripts).to eq([['mobile: scrollGesture', { elementId: list.id, direction: 'up', percent: 0.75 }]])
-      end
-    end
-
-    describe 'an unknown device' do
-      it 'raises NotImplementedError naming it, before waiting' do
-        windows = WaitHelperSpec::FakeDriver.new(device: :windows)
-        started = clock
-        expect { Page.new(windows).swipe('left', { id: 'never' }, timeout: 2) }
-          .to raise_error(NotImplementedError, /windows/)
-        expect { Page.new(windows).scroll('down') }.to raise_error(NotImplementedError, /windows/)
-        expect(clock - started).to be < 0.5
-      end
-    end
-
-    describe '#scroll_to' do
-      it 'returns a RaiderElement once the element turns visible after 2 scrolls' do
-        footer = element
-        driver.script({ accessibility_id: 'footer' }, nil, element(displayed: false), footer)
-        found = page.scroll_to({ accessibility_id: 'footer' }, timeout: 2)
-        expect(found).to be_a(App::RaiderElement).and eq(footer)
-        expect(driver.scripts).to eq([['mobile: scroll', { direction: 'down' }]] * 2)
-      end
-
-      it 'scrolls in the given direction' do
-        driver.script({ accessibility_id: 'header' }, nil, element)
-        page.scroll_to({ accessibility_id: 'header' }, direction: 'up', timeout: 2)
-        expect(driver.scripts).to eq([['mobile: scroll', { direction: 'up' }]])
-      end
-
-      it 'stops after max_scrolls scrolls and says so' do
-        started = clock
-        expect { page.scroll_to({ accessibility_id: 'footer' }, max_scrolls: 3, timeout: 5) }
-          .to raise_error(App::WaitHelper::TimeoutError) { |error|
-            expect(error.message).to include('to be visible').and include('after 3 scrolls')
-          }
-        expect(driver.scripts.size).to eq(3)
-        expect(driver.finds.size).to eq(4)
-        expect(clock - started).to be < 2
-      end
-
-      it 'also stops at the timeout, naming the scrolls so far' do
-        expect { page.scroll_to({ accessibility_id: 'footer' }, timeout: 0) }
-          .to raise_error(App::WaitHelper::TimeoutError, /after 0 scrolls/)
-        expect(driver.scripts).to be_empty
-      end
-    end
-
-    describe 'per-OS locators' do
-      it 'resolve on tap and swipe' do
-        card = element
-        android.script({ accessibility_id: 'android-card' }, card)
-        mobile = Page.new(android)
-        mobile.tap(per_os, timeout: 1)
-        mobile.swipe('right', per_os, timeout: 1)
-        expect(android.finds.uniq).to eq([{ accessibility_id: 'android-card' }])
-        expect([card.log, android.scripts.size]).to eq([[[:click]], 1])
-      end
-
-      it 'resolve on a nested find_element' do
-        row = element
-        list = element.script({ accessibility_id: 'ios-row' }, row)
-        driver.script({ accessibility_id: 'ios-card' }, list)
-        found = page.find_element(per_os).find_element({ ios: { accessibility_id: 'ios-row' }, android: { id: 'row' } })
-        expect(found).to eq(row)
-      end
-    end
-
-    describe 'RaiderElement' do
-      it 'has the mobile set without the locator' do
-        card = element
-        driver.script({ accessibility_id: 'card' }, card)
-        wrapper = page.find_element(accessibility_id: 'card')
-        expect(wrapper.tap.swipe('left').scroll('down').scroll_to).to be(wrapper)
-        expect(card.log).to eq([[:click]])
-        expect(driver.scripts).to eq([['mobile: swipe', { direction: 'left', element: card.id }],
-                                      ['mobile: scroll', { direction: 'down', element: card.id }]])
-      end
-
-      it 'adds exactly the planned public methods' do
-        expect(App::RaiderElement.public_instance_methods(false).sort)
-          .to eq(%i[== attribute clear click displayed? enabled? eql? find_element find_elements hash native scroll
-                    scroll_to selected? send_keys swipe tap text])
-      end
-    end
-
-    describe 'the choke point' do
-      let(:actions) { [] }
-
-      before do
-        driver.script({ id: 'x' }, element.script({ css: 'y' }, element).script_many({ css: 'y' }, [element]))
-        allow_any_instance_of(App::WaitHelper::Waiter).to receive(:perform_action).and_wrap_original do |original, *args, **options, &block|
-          actions << args.first
-          original.call(*args, **options, &block)
-        end
-      end
-
-      def calls(locator)
-        { find_element: [locator], find_elements: [locator], click: [locator], tap: [locator], clear: [locator],
-          text: [locator], displayed?: [locator], enabled?: [locator], selected?: [locator],
-          send_keys: [locator, 'a'], attribute: [locator, 'name'], swipe: ['left', locator],
-          scroll: ['down', locator], scroll_to: [locator] }
-      end
-
-      it 'is called once per mixin method, with the method name' do
-        calls({ id: 'x' }).each do |name, args|
-          actions.clear
-          page.public_send(name, *args, timeout: 1)
-          expect(actions).to eq([name])
-        end
-      end
-
-      it 'is called once for a whole-screen gesture' do
-        %i[swipe scroll].each do |name|
-          actions.clear
-          page.public_send(name, 'up')
-          expect(actions).to eq([name])
-        end
-      end
-
-      it 'is called once per wrapper method, with the method name' do
-        wrapper = page.find_element(id: 'x')
-        calls({ css: 'y' }).each do |name, args|
-          args = args.reject { |arg| arg.is_a?(Hash) } unless %i[find_element find_elements].include?(name)
-          actions.clear
-          wrapper.public_send(name, *args, timeout: 1)
-          expect(actions).to eq([name])
-        end
-      end
-    end
-
-    describe 'footprint' do
-      it 'adds exactly the mobile API, with no private methods and nothing named wait' do
-        expect(App::WaitHelper.public_instance_methods(false).sort)
-          .to eq(%i[attribute clear click displayed? enabled? eventually find_element find_elements scroll scroll_to
-                    selected? send_keys swipe tap text])
-        expect(App::WaitHelper.private_instance_methods(false)).to be_empty
-        expect(page.respond_to?(:wait, true)).to be(false)
-      end
-    end
-
-    describe '#eventually' do
-      it 'retries the block as on web' do
-        tries = 0
-        expect(page.eventually(timeout: 1) { expect(tries += 1).to eq(2) }).to be(true)
-      end
-
-      it 'retries a nested timeout: until its own deadline, as on web' do
-        started = clock
-        expect { page.eventually(timeout: 0.6) { page.text({ accessibility_id: 'never' }, timeout: 0.2) } }
-          .to raise_error(App::WaitHelper::TimeoutError, /\A\(still failing after 0.6s\)/)
-        expect(clock - started).to be_between(0.5, 1.0)
-      end
-
-      it 'raises at once for a stale find_elements member used as a parent' do
-        row = element.script({ accessibility_id: 'cell' }, element)
-        driver.script_many({ accessibility_id: 'row' }, [row])
-        member = page.find_elements(accessibility_id: 'row').first
-        row.go_stale
-        expect { member.find_element(accessibility_id: 'cell', timeout: 2) }
-          .to raise_error(Selenium::WebDriver::Error::StaleElementReferenceError, /find_elements again/)
-      end
-    end
-  end
-end