ruby_raider 3.11.0 → 3.12.0

data/lib/generators/templates/helpers/raider_element.tt

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+<%- if mobile? -%>
+# An element found through WaitHelper. It has the same waiting methods as the
+# mixin, minus the locator, so calls chain:
+#   find_element(accessibility_id: 'list').find_element(accessibility_id: 'row').tap
+#   find_element(accessibility_id: 'card').swipe('left')
+# Everything else (tag_name, rect, location, ...) goes to the raw Appium
+# element without waiting. APIs that type-check their argument
+# (driver.action, execute_script) need .native.
+<%- else -%>
+# An element found through WaitHelper. It has the same waiting methods as the
+# mixin, minus the locator, so calls chain:
+#   find_element(css: '.form').find_element(id: 'email').send_keys('a')
+# Everything else (tag_name, rect, property, ...) goes to the raw Selenium
+# element without waiting. Selenium APIs that type-check their argument
+# (switch_to.frame, Support::Select, driver.action, execute_script) need .native.
+<%- end -%>
+class RaiderElement
+  def initialize(driver, lookup)
+    @driver = driver
+    @lookup = lookup
+  end
+
+  def native
+    @lookup.element
+  end
+
+  def find_element(locator = nil, visible: true, timeout: nil, **by)
+    waiter(timeout).find_element(child(locator, by), visible)
+  end
+
+  def find_elements(locator = nil, timeout: nil, **by)
+    waiter(timeout).find_elements(child(locator, by))
+  end
+
+<%- if mobile? -%>
+  %i[click clear].each do |action|
+    define_method(action) do |timeout: nil|
+      perform(action, timeout) { |element| element.public_send(action) }
+      self
+    end
+  end
+
+  # tap is Appium's word for click. With a block it stays Ruby's Object#tap.
+  def tap(timeout: nil, &block)
+    return super(&block) if block
+
+    perform(:tap, timeout, &:click)
+    self
+  end
+<%- else -%>
+  %i[click clear submit].each do |action|
+    define_method(action) do |timeout: nil|
+      perform(action, timeout) { |element| element.public_send(action) }
+      self
+    end
+  end
+<%- end -%>
+
+  %i[text displayed? enabled? selected?].each do |reader|
+    define_method(reader) do |timeout: nil|
+      perform(reader, timeout) { |element| element.public_send(reader) }
+    end
+  end
+
+  def send_keys(*keys, timeout: nil)
+    perform(:send_keys, timeout) { |element| element.send_keys(*keys) }
+    self
+  end
+
+<%- unless mobile? -%>
+  def select_by(how, what, timeout: nil)
+    perform(:select_by, timeout) { |element| Selenium::WebDriver::Support::Select.new(element).select_by(how, what) }
+    self
+  end
+
+<%- end -%>
+  def attribute(name, timeout: nil)
+    perform(:attribute, timeout) { |element| element.attribute(name) }
+  end
+
+<%- if mobile? -%>
+  # direction: 'up', 'down', 'left' or 'right'.
+  %i[swipe scroll].each do |kind|
+    define_method(kind) do |direction, timeout: nil|
+      gesture = WaitHelper::Gesture.new(@driver, kind, direction)
+      perform(kind, timeout) { |element| gesture.perform(element) }
+      self
+    end
+  end
+
+  # Scrolls the screen until this element is visible, up to max_scrolls times.
+  def scroll_to(direction: 'down', max_scrolls: 10, timeout: nil)
+    scroller = WaitHelper::Scroller.new(WaitHelper::Gesture.new(@driver, :scroll, direction), max_scrolls)
+    waiter(timeout).perform_action(:scroll_to, @lookup, WaitHelper::Waiter::CHECKS[:scroll_to], between: scroller) { nil }
+    self
+  end
+<%- else -%>
+  def hover(timeout: nil)
+    perform(:hover, timeout) { |element| @driver.action.move_to(element).perform }
+    self
+  end
+
+  def scroll_into_view(timeout: nil)
+    perform(:scroll_into_view, timeout) { |element| @driver.action.scroll_to(element).perform }
+    self
+  end
+
+  # target: a RaiderElement, a raw element, or a driver-scoped locator.
+  def drag_and_drop(target, timeout: nil)
+    drop = WaitHelper::Lookup.for(@driver, target, {})
+    waiter(timeout).perform_action(:drag_and_drop, @lookup, WaitHelper::Waiter::CHECKS[:drag_and_drop],
+                                   target: drop) do |source, destination|
+      @driver.action.drag_and_drop(source, destination).perform
+    end
+    self
+  end
+<%- end -%>
+
+  def ==(other)
+    native == (other.is_a?(RaiderElement) ? other.native : other)
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    native.hash
+  end
+
+  private
+
+  # WaitHelper::Lookup.for reads this to reuse how a wrapper was found.
+  attr_reader :lookup
+
+  def waiter(timeout)
+    WaitHelper::Waiter.new(@driver, timeout: timeout)
+  end
+
+  def child(locator, by)
+    WaitHelper::Lookup.for(@driver, locator, by, scope: @lookup)
+  end
+
+  def perform(action, timeout, &block)
+    waiter(timeout).perform_action(action, @lookup, WaitHelper::Waiter::CHECKS.fetch(action), &block)
+  end
+
+  def method_missing(name, *args, **options, &block)
+    return super unless native.respond_to?(name)
+
+    native.public_send(name, *args, **options, &block)
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    native.respond_to?(name) || super
+  end
+end

data/lib/generators/templates/helpers/session_state.tt

@@ -74,10 +74,17 @@ class SessionState
 
   private
 
+  # Warnings wait until the outcome is known: a peer's save can still rescue a failed restore,
+  # and each fallback warns once, only when it really logs in.
   def reuse_locked(lock, valid, &login)
-    lock.flock(File::LOCK_EX)
-    return if ENV.fetch('RAIDER_LOGIN_STATE', nil) != 'refresh' && fresh? && restore && still_valid?(valid)
-
+    @reason = @note = nil
+    @deferred = true
+    reused = reused?(lock, valid)
+    @deferred = false
+    return warn(@note) if reused && @note
+    return if reused
+
+    warn("[login_state] #{@reason}, logging in again") if @reason
     clear
     reset if @applied
     login.call
@@ -86,6 +93,35 @@ class SessionState
     lock.close
   end
 
+  # Restores under a shared lock, so parallel workers restore at the same time; only a real
+  # login takes the exclusive lock. Upgrading drops the shared lock first, so a worker that
+  # gets the exclusive lock after another one saved restores that login instead.
+  def reused?(lock, valid)
+    if ENV.fetch('RAIDER_LOGIN_STATE', nil) == 'refresh'
+      lock.flock(File::LOCK_EX)
+      return false
+    end
+    lock.flock(File::LOCK_SH)
+    seen = saved_signature
+    return true if restored?(valid)
+
+    lock.flock(File::LOCK_UN) # Windows will not upgrade a held shared lock in place
+    lock.flock(File::LOCK_EX)
+    saved_signature != seen && restored?(valid)
+  end
+
+  def restored?(valid)
+    fresh? && restore && still_valid?(valid)
+  end
+
+  # inode, mtime and size: mtime alone misses a save in the same second on coarse filesystems
+  def saved_signature
+    stat = File.stat(path)
+    [stat.ino, stat.mtime, stat.size]
+  rescue SystemCallError
+    nil
+  end
+
   def open_lock
     ensure_dir
     File.open(File.join(DIR, "#{name}.lock"), File::RDWR | File::CREAT, 0o600)
@@ -123,7 +159,7 @@ class SessionState
     @driver.manage.delete_all_cookies
     live, skipped = state['cookies'].partition { |cookie| live_for_origin?(cookie) }
     live.each { |cookie| add_cookie(load_cookie(cookie)) }
-    warn("[login_state] #{skipped.size} cookies skipped (expired or another domain) from #{path}") if skipped.any?
+    note("[login_state] #{skipped.size} cookies skipped (expired or another domain) from #{path}") if skipped.any?
     STORAGES.each { |key, kind| @driver.execute_script(WRITE_STORAGE, kind, state[key] || {}) }
     @driver.navigate.refresh
     true
@@ -200,7 +236,11 @@ class SessionState
   end
 
   def fall_back(reason)
-    warn("[login_state] #{reason}, logging in again")
+    @deferred ? (@reason ||= reason) : warn("[login_state] #{reason}, logging in again")
     false
   end
+
+  def note(message)
+    @deferred ? @note = message : warn(message)
+  end
 end

data/lib/generators/templates/helpers/spec_helper.tt

@@ -13,8 +13,13 @@ require_relative 'browser_helper'
 require_relative 'driver_helper'
 <%- end -%>
 require_relative 'video_helper'
+<%- if wait_helper? -%>
+require_relative 'wait_helper'
+<%- end -%>
 <%- if web? -%>
 require_relative 'session_state'
+<%- end -%>
+<%- if web? && examples? -%>
 require_relative '../models/model_factory'
 require_relative '../page_objects/pages/login'
 require_relative '../page_objects/pages/account'
@@ -32,6 +37,9 @@ module SpecHelper
     <%- else -%>
     config.include(DriverHelper)
     <%- end -%>
+    <%- if wait_helper? -%>
+    config.include(WaitHelper)
+    <%- end -%>
     <%- if mobile? -%>
     config.before(:each) do
       driver.start_driver
@@ -55,7 +63,7 @@ module SpecHelper
       @video_recorder = VideoHelper.recorder_for(<%= watir? ? 'browser' : 'driver' %>)
       @video_recorder.start
     end
-<%- if web? -%>
+<%- if web? && examples? -%>
 
     config.before(:each, :logged_in) do
       user = ModelFactory.for('users')['registered user']