ruby_raider 2.0.0 → 3.0.0

data/lib/generators/templates/helpers/partials/selenium_driver.tt

@@ -1,7 +1,9 @@
   def create_driver(*opts)
     @config = YAML.load_file('config/config.yml')
     browser = @config['browser']
-    Selenium::WebDriver.for(browser.to_sym, options: create_webdriver_options(*opts))
+    driver = Selenium::WebDriver.for(browser.to_sym, options: create_webdriver_options(*opts))
+    driver.manage.timeouts.implicit_wait = @config.fetch('timeout', 10)
+    driver
   end
 
   def browser_arguments(*opts)
@@ -10,16 +12,15 @@
     args
   end
 
-  def driver_options
-    @config['driver_options']
-  end
-
-  # :reek:FeatureEnvy
   def create_webdriver_options(*opts)
     load_browser = @config['browser'].to_s
     browser = load_browser == 'ie' ? load_browser.upcase : load_browser.capitalize
     options = "Selenium::WebDriver::#{browser}::Options".constantize.new
     browser_arguments(*opts).each { |arg| options.add_argument(arg) }
-    driver_options.each { |opt| options.add_option(opt.first, opt.last) }
+    debug_cfg = @config['debug'] || {}
+    if %w[chrome edge msedge].include?(@config['browser'].to_s.downcase) &&
+       (debug_cfg.fetch('enabled', false) || ENV['DEBUG']&.downcase == 'true')
+      options.add_option('goog:loggingPrefs', { browser: 'ALL', performance: 'ALL' })
+    end
     options
   end

data/lib/generators/templates/helpers/partials/video_start.tt

@@ -0,0 +1,9 @@
+<% if capybara? %>
+  @video_recorder = VideoHelper.recorder_for(Capybara.current_session.driver)
+<% elsif selenium_based? %>
+  @video_recorder = VideoHelper.recorder_for(driver)
+<% elsif watir? %>
+  @video_recorder = VideoHelper.recorder_for(browser)
+<% else %>
+  @video_recorder = VideoHelper.recorder_for(driver)
+<% end %>

data/lib/generators/templates/helpers/partials/video_stop.tt

@@ -0,0 +1,4 @@
+  video_file = @video_recorder&.stop
+<% if allure_reporter? %>
+  AllureHelper.add_video(example_name, video_file)
+<% end %>

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+require 'fileutils'
+require 'yaml'
+
+module PerformanceHelper
+  REPORTS_DIR = 'lighthouse_reports'
+
+  def run_lighthouse_audit(url, categories: %w[performance accessibility best-practices seo])
+    FileUtils.mkdir_p(REPORTS_DIR)
+
+    report_path = File.join(REPORTS_DIR, "report_#{Time.now.to_i}.json")
+    category_flags = categories.map { |c| "--only-categories=#{c}" }.join(' ')
+
+    config_timeout = if File.exist?('config/config.yml')
+                        YAML.load_file('config/config.yml').fetch('timeout', 10)
+                      else
+                        10
+                      end
+    max_wait = config_timeout * 1000
+
+    command = "lighthouse #{url} --output=json --output-path=#{report_path} " \
+              "--chrome-flags=\"--headless --no-sandbox\" #{category_flags} " \
+              "--max-wait-for-load=#{max_wait} --quiet"
+
+    stdout, stderr, status = Open3.capture3(command)
+
+    unless status.success?
+      return { status: :error, message: "Lighthouse failed: #{stderr.strip.empty? ? stdout : stderr}" }
+    end
+
+    report = JSON.parse(File.read(report_path))
+    scores = extract_scores(report)
+
+    { status: :success, scores:, report_path: }
+  end
+
+  def assert_performance_above(url, threshold: 0.8, categories: %w[performance])
+    result = run_lighthouse_audit(url, categories:)
+    return result if result[:status] == :error
+
+    passed = result[:scores].all? { |_category, score| score >= threshold }
+
+    { status: passed ? :pass : :fail, scores: result[:scores], passed:, threshold:,
+      report_path: result[:report_path] }
+  end
+
+  private
+
+  def extract_scores(report)
+    report.fetch('categories', {}).each_with_object({}) do |(key, data), scores|
+      scores[key] = data['score']
+    end
+  end
+end

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

@@ -1,11 +1,18 @@
 # 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'
+<%- end -%>
+<%- unless skip_video? -%>
+require_relative 'video_helper'
+<%- end -%>
+require_relative 'debug_helper'
 <%- if capybara? -%>
 require_relative 'capybara_helper'
 <%- elsif watir? -%>
@@ -16,9 +23,23 @@ 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
+    <%- 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
@@ -30,26 +51,54 @@ module SpecHelper
     <%- if mobile? -%>
     config.before(:each) do
       driver.start_driver
-    end
     <%- elsif capybara? -%>
     config.before(:each) do
-      Capybara.current_session.driver.browser.manage.window.maximize
-    end
+      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|
         <%= partial('screenshot', strip: true) %>
+        <%- if allure_reporter? -%>
         AllureHelper.add_screenshot(example_name, screenshot)
+        <%- end -%>
       end
       <%= partial('quit_driver', strip: true) %>
     end

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

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
-<%- if axe? %>
+<%- 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? -%>
@@ -14,13 +20,75 @@ require_relative 'capybara_helper'
 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