ruby_raider 1.1.4 → 3.0.0

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

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
-<%- if axe? %>
+<%- if axe_addon? %>
 require 'axe-rspec'
 <%- end -%>
 require 'rspec'
+require 'rspec/retry'
 require 'tmpdir'
+<%- if allure_reporter? -%>
 require_relative 'allure_helper'
-<%- if watir? -%>
+<%- end -%>
+<%- unless skip_video? -%>
+require_relative 'video_helper'
+<%- end -%>
+require_relative 'debug_helper'
+<%- if capybara? -%>
+require_relative 'capybara_helper'
+<%- elsif watir? -%>
 require_relative 'browser_helper'
 <%- else -%>
 require_relative 'driver_helper'
@@ -14,31 +23,84 @@ require_relative 'driver_helper'
 
 module SpecHelper
 
+  <%- if allure_reporter? -%>
   AllureHelper.configure
+  <%- end -%>
   RSpec.configure do |config|
+    config.example_status_persistence_file_path = 'spec/examples.txt'
+    config.verbose_retry = true
+    config.display_try_failure_messages = true
+    config.default_retry_count = ENV.fetch('RETRY_COUNT', 0).to_i
+    <%- if allure_reporter? -%>
     config.formatter = AllureHelper.formatter
-    <% if watir? %>config.include(BrowserHelper)<% else %>config.include(DriverHelper)<% end %>
+    <%- end -%>
+    <%- if junit_reporter? -%>
+    config.add_formatter('RspecJunitFormatter', 'results/junit.xml')
+    <%- end -%>
+    <%- if json_reporter? -%>
+    config.add_formatter('json', 'results/results.json')
+    <%- end -%>
+    <%- if capybara? -%>
+    config.include(Capybara::DSL)
+    CapybaraHelper.configure
+    <%- elsif watir? -%>
+    config.include(BrowserHelper)
+    <%- else -%>
+    config.include(DriverHelper)
+    <%- end -%>
     <%- if mobile? -%>
     config.before(:each) do
       driver.start_driver
-    end
+    <%- elsif capybara? -%>
+    config.before(:each) do
+      viewport = YAML.load_file('config/config.yml')['viewport']
+      if viewport
+        Capybara.current_session.driver.browser.manage.window.resize_to(viewport['width'], viewport['height'])
+      else
+        Capybara.current_session.driver.browser.manage.window.maximize
+      end
     <%- elsif selenium_based? -%>
     config.before(:each) do
-      driver.manage.window.maximize
-    end
+      viewport = YAML.load_file('config/config.yml')['viewport']
+      if viewport
+        driver.manage.window.resize_to(viewport['width'], viewport['height'])
+      else
+        driver.manage.window.maximize
+      end
     <%- elsif watir? -%>
     config.before(:each) do
-      browser.window.maximize
-    end
+      viewport = YAML.load_file('config/config.yml')['viewport']
+      if viewport
+        browser.window.resize_to(viewport['width'], viewport['height'])
+      else
+        browser.window.maximize
+      end
     <%- end -%>
+      <%- unless skip_video? -%>
+      <%= partial('video_start', strip: true) %>
+      @video_recorder&.start(self.class.description)
+      <%- end -%>
+      <%= partial('debug_start', strip: true) %>
+      @debug_action_logger = DebugHelper.action_logger_for(self.class.description)
+    end
 
     config.after(:each) do |example|
       example_name = example.description
+      if example.exception
+        @_exception = example.exception
+        <%= partial('debug_diagnostics', strip: true) %>
+      end
+      @debug_action_logger&.close
+      <%- unless skip_video? -%>
+      <%= partial('video_stop', strip: true) %>
+      <%- end -%>
       Dir.mktmpdir do |temp_folder|
-        <%= ERB.new(File.read(File.expand_path('./partials/screenshot.tt', __dir__)), trim_mode: '-').result(binding).strip! %>
+        <%= partial('screenshot', strip: true) %>
+        <%- if allure_reporter? -%>
         AllureHelper.add_screenshot(example_name, screenshot)
+        <%- end -%>
       end
-      <%= ERB.new(File.read(File.expand_path('./partials/quit_driver.tt', __dir__)), trim_mode: '-').result(binding).strip! %>
+      <%= partial('quit_driver', strip: true) %>
     end
   end
 end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+<%- if axe_addon? %>
+require 'axe-minitest'
+<%- end -%>
+require 'minitest/autorun'
+require 'tmpdir'
+<%- if allure_reporter? -%>
+require_relative 'allure_helper'
+<%- end -%>
+<%- unless skip_video? -%>
+require_relative 'video_helper'
+<%- end -%>
+require_relative 'debug_helper'
+<%- if watir? -%>
+require_relative 'browser_helper'
+<%- elsif capybara? -%>
+require_relative 'capybara_helper'
+<%- else -%>
+require_relative 'driver_helper'
+<%- end -%>
+
+<%- if allure_reporter? -%>
+AllureHelper.configure
+<%- end -%>
+<%- if capybara? -%>
+CapybaraHelper.configure
+<%- end -%>
+<%- if json_reporter? -%>
+require 'minitest/reporters'
+Minitest::Reporters.use! [Minitest::Reporters::JsonReporter.new('results/results.json')]
+<%- end -%>
+
+module TestHelper
+  <% if watir? %>include BrowserHelper<% elsif capybara? %>include Capybara::DSL<% else %>include DriverHelper<% end %>
+
+  def setup
+    super
+<%- if mobile? -%>
+    driver.start_driver
+<%- elsif capybara? -%>
+    viewport = YAML.load_file('config/config.yml')['viewport']
+    if viewport
+      Capybara.current_session.driver.browser.manage.window.resize_to(viewport['width'], viewport['height'])
+    else
+      Capybara.current_session.driver.browser.manage.window.maximize
+    end
+<%- elsif watir? -%>
+    viewport = YAML.load_file('config/config.yml')['viewport']
+    if viewport
+      browser.window.resize_to(viewport['width'], viewport['height'])
+    else
+      browser.window.maximize
+    end
+<%- else -%>
+    viewport = YAML.load_file('config/config.yml')['viewport']
+    if viewport
+      driver.manage.window.resize_to(viewport['width'], viewport['height'])
+    else
+      driver.manage.window.maximize
+    end
+<%- end -%>
+    <%- unless skip_video? -%>
+    <%= partial('video_start', strip: true) %>
+    @video_recorder&.start(self.class.name)
+    <%- end -%>
+    <%= partial('debug_start', strip: true) %>
+    @debug_action_logger = DebugHelper.action_logger_for(self.class.name)
+  end
+
+  def teardown
+    example_name = name
+    unless passed?
+      <%= partial('debug_diagnostics', strip: true) %>
+    end
+    @debug_action_logger&.close
+    <%- unless skip_video? -%>
+    video_file = @video_recorder&.stop
+    <%- if allure_reporter? -%>
+    AllureHelper.add_video(example_name, video_file)
+    <%- end -%>
+    <%- end -%>
+    Dir.mktmpdir do |temp_folder|
+      <%= partial('screenshot', strip: true) %>
+      <%- if allure_reporter? -%>
+      AllureHelper.add_screenshot(example_name, screenshot)
+      <%- end -%>
+    end
+    <%= partial('quit_driver', strip: true) %>
+    super
+  end
+end
+
+Minitest::Test.include(TestHelper)

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require 'json'
+require 'base64'
+
+module VideoHelper
+  VIDEO_DIR = 'videos'
+
+  module_function
+
+  def config
+    @config ||= begin
+      yml = YAML.load_file('config/config.yml')
+      yml['video'] || {}
+    rescue StandardError
+      {}
+    end
+  end
+
+  def enabled?
+    config.fetch('enabled', false)
+  end
+
+  def recorder_for(driver_or_browser)
+    return NullRecorder.new unless enabled?
+
+    strategy = config.fetch('strategy', 'auto')
+    case strategy
+    when 'cdp' then CdpRecorder.new(resolve_selenium_driver(driver_or_browser))
+    when 'screen' then ScreenCaptureRecorder.new
+<%- if mobile? -%>
+    when 'appium' then AppiumRecorder.new(driver_or_browser)
+<%- end -%>
+    when 'auto' then auto_detect(driver_or_browser)
+    else NullRecorder.new
+    end
+  end
+
+  def auto_detect(driver_or_browser)
+    sel_driver = resolve_selenium_driver(driver_or_browser)
+<%- if mobile? -%>
+    return AppiumRecorder.new(driver_or_browser) if defined?(Appium::Driver)
+<%- end -%>
+    return CdpRecorder.new(sel_driver) if chrome_or_edge?(sel_driver)
+
+    if ffmpeg_available?
+      ScreenCaptureRecorder.new
+    else
+      NullRecorder.new
+    end
+  end
+
+  def resolve_selenium_driver(obj)
+    if obj.respond_to?(:driver) && !obj.is_a?(Selenium::WebDriver::Driver)
+      obj.driver
+    elsif obj.respond_to?(:browser) && obj.browser.respond_to?(:driver)
+      obj.browser.driver
+    else
+      obj
+    end
+  rescue StandardError
+    obj
+  end
+
+  def chrome_or_edge?(driver)
+    browser_name = driver.capabilities[:browser_name].to_s.downcase
+    %w[chrome chromium msedge edge].any? { |b| browser_name.include?(b) }
+  rescue StandardError
+    false
+  end
+
+  def ffmpeg_available?
+    system('ffmpeg -version > /dev/null 2>&1') ||
+      system('ffmpeg -version > NUL 2>&1')
+  end
+
+  def ensure_video_dir
+    FileUtils.mkdir_p(VIDEO_DIR)
+  end
+
+  # --- CDP Recorder: Chrome/Edge, works headless ---
+
+  class CdpRecorder
+    def initialize(driver)
+      @driver = driver
+      @frames = []
+      @recording = false
+    end
+
+    def start(test_name)
+      @test_name = sanitize(test_name)
+      @frames = []
+      @frame_index = 0
+      @recording = true
+      @driver.execute_cdp('Page.startScreencast',
+                          format: 'jpeg', quality: 60,
+                          maxWidth: 1280, maxHeight: 720,
+                          everyNthFrame: 2)
+      start_frame_collector
+    rescue StandardError => e
+      warn "[video] CDP recording failed to start: #{e.message}"
+      @recording = false
+    end
+
+    def stop
+      return nil unless @recording
+
+      @recording = false
+      @driver.execute_cdp('Page.stopScreencast')
+      sleep 0.2 # allow final frames to arrive
+      assemble_video
+    rescue StandardError => e
+      warn "[video] CDP recording failed to stop: #{e.message}"
+      nil
+    end
+
+    private
+
+    def start_frame_collector
+      @collector = Thread.new do
+        while @recording
+          begin
+            collect_frame
+          rescue StandardError
+            sleep 0.1
+          end
+          sleep 0.05
+        end
+      end
+    end
+
+    def collect_frame
+      # CDP screencast events are handled by polling via execute_cdp
+      # We capture screenshots at intervals as a reliable alternative
+      VideoHelper.ensure_video_dir
+      frame_path = File.join(VideoHelper::VIDEO_DIR, "#{@test_name}_frame_#{format('%04d', @frame_index)}.jpg")
+      @driver.save_screenshot(frame_path)
+      @frames << frame_path
+      @frame_index += 1
+    end
+
+    def assemble_video
+      return nil if @frames.empty?
+
+      @collector&.join(2)
+      VideoHelper.ensure_video_dir
+      output = File.join(VideoHelper::VIDEO_DIR, "#{@test_name}.mp4")
+      pattern = File.join(VideoHelper::VIDEO_DIR, "#{@test_name}_frame_%04d.jpg")
+
+      system("ffmpeg -y -framerate 10 -i \"#{pattern}\" -c:v libx264 -pix_fmt yuv420p " \
+             "-movflags +faststart -loglevel error \"#{output}\"")
+
+      cleanup_frames
+      File.exist?(output) ? output : nil
+    end
+
+    def cleanup_frames
+      @frames.each { |f| FileUtils.rm_f(f) }
+    end
+
+    def sanitize(name)
+      name.gsub(/[^a-zA-Z0-9_-]/, '_')[0..80]
+    end
+  end
+
+  # --- Screen Capture Recorder: Any browser, requires FFmpeg + display ---
+
+  class ScreenCaptureRecorder
+    def initialize
+      @recording = false
+    end
+
+    def start(test_name)
+      @test_name = sanitize(test_name)
+      VideoHelper.ensure_video_dir
+      @output = File.join(VideoHelper::VIDEO_DIR, "#{@test_name}.mp4")
+      @recording = true
+
+      input = screen_input
+      @pid = spawn("ffmpeg -y #{input} -r 15 -c:v libx264 -pix_fmt yuv420p " \
+                   "-loglevel error \"#{@output}\"",
+                   %i[out err] => '/dev/null')
+    rescue StandardError => e
+      warn "[video] Screen recording failed to start: #{e.message}"
+      @recording = false
+    end
+
+    def stop
+      return nil unless @recording
+
+      @recording = false
+      Process.kill('INT', @pid)
+      Process.wait(@pid)
+      File.exist?(@output) ? @output : nil
+    rescue StandardError => e
+      warn "[video] Screen recording failed to stop: #{e.message}"
+      nil
+    end
+
+    private
+
+    def screen_input
+      case RbConfig::CONFIG['host_os']
+      when /darwin/i
+        '-f avfoundation -i "1:none"'
+      when /linux/i
+        display = ENV.fetch('DISPLAY', ':99')
+        "-f x11grab -i #{display}"
+      when /mswin|mingw|cygwin/i
+        '-f gdigrab -i desktop'
+      else
+        '-f x11grab -i :0'
+      end
+    end
+
+    def sanitize(name)
+      name.gsub(/[^a-zA-Z0-9_-]/, '_')[0..80]
+    end
+  end
+
+<%- if mobile? -%>
+  # --- Appium Recorder: Mobile, uses native API ---
+
+  class AppiumRecorder
+    def initialize(driver)
+      @driver = driver
+      @recording = false
+    end
+
+    def start(test_name)
+      @test_name = sanitize(test_name)
+      @recording = true
+      @driver.start_recording_screen
+    rescue StandardError => e
+      warn "[video] Appium recording failed to start: #{e.message}"
+      @recording = false
+    end
+
+    def stop
+      return nil unless @recording
+
+      @recording = false
+      video_base64 = @driver.stop_recording_screen
+      VideoHelper.ensure_video_dir
+      output = File.join(VideoHelper::VIDEO_DIR, "#{@test_name}.mp4")
+      File.write(output, Base64.decode64(video_base64), mode: 'wb')
+      output
+    rescue StandardError => e
+      warn "[video] Appium recording failed to stop: #{e.message}"
+      nil
+    end
+
+    private
+
+    def sanitize(name)
+      name.gsub(/[^a-zA-Z0-9_-]/, '_')[0..80]
+    end
+  end
+
+<%- end -%>
+  # --- Null Recorder: Fallback when recording unavailable ---
+
+  class NullRecorder
+    def start(_test_name) = nil
+
+    def stop = nil
+  end
+end

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

@@ -1,65 +1,58 @@
 # frozen_string_literal: true
 
-require 'active_support/inflector'
-require 'eyes_selenium'
-require 'yaml'
+require 'chunky_png'
+require 'fileutils'
 
 module VisualHelper
-    attr_reader :eyes
+  BASELINE_DIR = 'visual_baselines'
+  DIFF_DIR = 'visual_diffs'
 
-    SELENIUM = Applitools::Selenium
-    VISUAL_GRID = SELENIUM::VisualGridRunner
-    EYES = SELENIUM::Eyes
-    TARGET = SELENIUM::Target
-    BATCHINFO = Applitools::BatchInfo
-    REGTANGLE_SIZE = Applitools::RectangleSize
+  def compare_screenshot(name, screenshot_path, threshold: 0.01)
+    FileUtils.mkdir_p(BASELINE_DIR)
+    FileUtils.mkdir_p(DIFF_DIR)
 
-    def create_grid_runner(concurrency = 1)
-      VISUAL_GRID.new(concurrency)
-    end
+    baseline_path = File.join(BASELINE_DIR, "#{name}.png")
 
-    def create_eyes(grid_runner)
-      EYES.new(runner: grid_runner)
+    unless File.exist?(baseline_path)
+      FileUtils.cp(screenshot_path, baseline_path)
+      return { status: :baseline_created, path: baseline_path }
     end
 
-    def check_page(page)
-      page = format_page(page)
-      @eyes.check(page, TARGET.window.fully)
-    end
+    baseline = ChunkyPNG::Image.from_file(baseline_path)
+    current = ChunkyPNG::Image.from_file(screenshot_path)
 
-    def configure_eyes(eyes, options = nil)
-      options ||= YAML.load_file('config/options.yml')
+    diff_pixels = 0
+    total_pixels = baseline.width * baseline.height
 
-      eyes.configure do |conf|
-        #  You can get your api key from the Applitools dashboard
-        general_config(options, conf)
-        add_browsers(options[:browsers], conf)
-        add_devices(options[:devices], conf)
+    diff_image = ChunkyPNG::Image.new(baseline.width, baseline.height)
+
+    baseline.height.times do |y|
+      baseline.width.times do |x|
+        if pixel_match?(baseline[x, y], current[x, y])
+          diff_image[x, y] = ChunkyPNG::Color.rgba(0, 0, 0, 50)
+        else
+          diff_pixels += 1
+          diff_image[x, y] = ChunkyPNG::Color.rgb(255, 0, 0)
+        end
       end
     end
 
-    def format_page(page)
-      page.instance_of?(String) ? page : page.to_s
-    end
+    diff_percentage = diff_pixels.to_f / total_pixels
 
-    def add_browsers(browsers, conf)
-      browsers.each do |browser|
-        conf.add_browser(browser[:height], browser[:width], "BrowserType::#{browser[:name].upcase}".constantize)
-      end
+    if diff_percentage > threshold
+      diff_path = File.join(DIFF_DIR, "#{name}_diff.png")
+      diff_image.save(diff_path)
+      { status: :mismatch, diff: diff_percentage, diff_path: }
+    else
+      { status: :match, diff: diff_percentage }
     end
+  end
 
-    def add_devices(devices, conf)
-      devices.each do |device|
-        conf.add_device_emulation("Devices::#{device[:name]}".constantize,
-                                  "Orientation::#{device[:orientation]}".constantize)
-      end
-    end
+  private
 
-    def general_config(options, conf)
-      conf.api_key = ENV['APPLITOOLS_API_KEY']
-      conf.batch = BATCHINFO.new(options[:batch_name])
-      conf.app_name = options[:app_name]
-      conf.test_name = options[:test_name]
-      conf.viewport_size = REGTANGLE_SIZE.new(options[:viewport_size][:height], options[:viewport_size][:width])
-    end
+  def pixel_match?(pixel1, pixel2)
+    r1, g1, b1 = ChunkyPNG::Color.r(pixel1), ChunkyPNG::Color.g(pixel1), ChunkyPNG::Color.b(pixel1)
+    r2, g2, b2 = ChunkyPNG::Color.r(pixel2), ChunkyPNG::Color.g(pixel2), ChunkyPNG::Color.b(pixel2)
+    (r1 - r2).abs <= 5 && (g1 - g2).abs <= 5 && (b1 - b2).abs <= 5
+  end
 end

data/lib/llm/client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require_relative 'config'
+
+module Llm
+  # Facade for LLM completion with retry logic and graceful fallback.
+  # Returns nil on any failure — callers should always have a non-AI fallback.
+  module Client
+    MAX_RETRIES = 3
+    BASE_DELAY = 1
+
+    # Only retry on transient network errors, not configuration or API errors
+    RETRYABLE_ERRORS = [
+      Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED,
+      Errno::ECONNRESET, Errno::ETIMEDOUT, SocketError
+    ].freeze
+
+    class << self
+      def complete(prompt, system_prompt: nil)
+        provider = build_provider
+        return nil unless provider
+
+        attempt = 0
+        begin
+          attempt += 1
+          provider.complete(prompt, system_prompt:)
+        rescue *RETRYABLE_ERRORS => e
+          if attempt < MAX_RETRIES
+            sleep(BASE_DELAY * (2**(attempt - 1)))
+            retry
+          end
+          warn "[Ruby Raider] LLM failed after #{MAX_RETRIES} attempts: #{e.message}"
+          nil
+        rescue StandardError => e
+          warn "[Ruby Raider] LLM error: #{e.message}"
+          nil
+        end
+      end
+
+      def available?
+        config = Config.new
+        return false unless config.configured?
+
+        provider = config.build_provider
+        provider&.available? || false
+      end
+
+      def status
+        config = Config.new
+        return { configured: false, provider: nil } unless config.configured?
+
+        provider = config.build_provider
+        {
+          configured: true,
+          provider: config.provider_name,
+          model: config.model,
+          available: provider&.available? || false
+        }
+      end
+
+      private
+
+      def build_provider
+        config = Config.new
+        unless config.configured?
+          warn '[Ruby Raider] No LLM configured. Use: raider u llm ollama'
+          return nil
+        end
+        provider = config.build_provider
+        unless provider&.available?
+          warn "[Ruby Raider] LLM provider '#{config.provider_name}' is not available"
+          return nil
+        end
+        provider
+      end
+    end
+  end
+end