lookbook_visual_tester 0.5.10 → 0.7.0

data/lib/lookbook_visual_tester/runner.rb

@@ -3,6 +3,7 @@ require 'json'
 require_relative 'configuration'
 require_relative 'scenario_run'
 require_relative 'services/image_comparator'
+require_relative 'services/image_trimmer'
 require_relative 'drivers/ferrum_driver'
 require_relative 'variant_resolver'
 
@@ -11,10 +12,14 @@ module LookbookVisualTester
     Result = Struct.new(:scenario_name, :status, :mismatch, :diff_path, :error, :baseline_path,
                         :current_path, keyword_init: true)
 
-    def initialize(config = LookbookVisualTester.config, pattern: nil, force_update: false)
+    DEFAULT_DRIVER_WIDTH = 1280
+    DEFAULT_DRIVER_HEIGHT = 800
+
+    def initialize(config = LookbookVisualTester.config, pattern: nil, force_update: false, output: $stdout)
       @config = config
       @pattern = pattern
       @force_update = force_update
+      @output = output
       @driver_pool = Queue.new
       init_driver_pool
       @results = []
@@ -31,8 +36,8 @@ module LookbookVisualTester
         end
       end
 
-      puts "Found #{previews.count} previews matching '#{@pattern}'."
-      puts "Running against #{@variants.size} variant(s)."
+      @output.puts "Found #{previews.count} previews matching '#{@pattern}'."
+      @output.puts "Running against #{@variants.size} variant(s)."
 
       @variants.each do |variant_input|
         resolver = VariantResolver.new(variant_input)
@@ -40,7 +45,7 @@ module LookbookVisualTester
         variant_slug = resolver.slug
         width = resolver.width_in_pixels
 
-        puts "  Variant: #{variant_slug.presence || 'Default'}"
+        @output.puts "  Variant: #{variant_slug.presence || 'Default'}"
 
         if @config.threads > 1
           run_concurrently(previews, variant_slug, variant_options, width)
@@ -63,15 +68,18 @@ module LookbookVisualTester
       begin
         JSON.parse(variants_json)
       rescue JSON::ParserError
-        puts 'Invalid JSON in VARIANTS env var. Defaulting to standard run.'
+        @output.puts 'Invalid JSON in VARIANTS env var. Defaulting to standard run.'
         [{}]
       end
     end
 
+    def scenarios_for(preview)
+      preview.scenarios
+    end
+
     def run_sequentially(previews, variant_slug, variant_options, width)
       previews.each do |preview|
-        group = preview.respond_to?(:scenarios) ? preview.scenarios : preview.examples
-        group.each do |scenario|
+        scenarios_for(preview).each do |scenario|
           driver = checkout_driver
           begin
             @results << run_scenario(scenario, driver, variant_slug, variant_options, width)
@@ -88,8 +96,7 @@ module LookbookVisualTester
       promises = []
 
       previews.each do |preview|
-        group = preview.respond_to?(:scenarios) ? preview.scenarios : preview.examples
-        group.each do |scenario|
+        scenarios_for(preview).each do |scenario|
           promises << Concurrent::Promises.future_on(pool) do
             driver = checkout_driver
             begin
@@ -101,8 +108,6 @@ module LookbookVisualTester
         end
       end
 
-      # Zip results from this concurrent batch into results
-      # Note: This aggregates results per variant loop.
       @results.concat(Concurrent::Promises.zip(*promises).value)
       pool.shutdown
       pool.wait_for_termination
@@ -110,9 +115,7 @@ module LookbookVisualTester
 
     def init_driver_pool
       count = @config.threads > 1 ? @config.threads : 1
-      count.times do
-        @driver_pool << LookbookVisualTester::Drivers::FerrumDriver.new(@config)
-      end
+      count.times { @driver_pool << Drivers::FerrumDriver.new(@config) }
     end
 
     def checkout_driver
@@ -133,98 +136,111 @@ module LookbookVisualTester
     def run_scenario(scenario, driver, variant_slug, variant_options, width)
       run_data = ScenarioRun.new(scenario, variant_slug: variant_slug,
                                            display_params: variant_options)
-      puts "Running visual test for: #{run_data.name} #{variant_slug.present? ? "[#{variant_slug}]" : ''}"
+      @output.puts "Running visual test for: #{run_data.name} #{variant_slug.present? ? "[#{variant_slug}]" : ''}"
 
+      paths = prepare_paths(run_data, variant_slug)
+      Thread.current[:lookbook_visual_tester_driver] = driver
       begin
-        driver_width = width || 1280
-        driver.resize_window(driver_width, 800)
-        driver.visit(run_data.preview_url)
+        capture(driver, run_data, paths, width)
+        compare_against_baseline(run_data, paths)
+      rescue StandardError => e
+        record_failure(run_data, paths, e)
+      ensure
+        Thread.current[:lookbook_visual_tester_driver] = nil
+      end
+    end
 
-        # Determine paths
-        current_path = run_data.current_path
-        baseline_path = run_data.baseline_path
-        folder_name = variant_slug.presence || 'default'
-        diff_path = @config.diff_dir.join(folder_name, run_data.diff_filename)
+    def prepare_paths(run_data, variant_slug)
+      folder_name = variant_slug.presence || 'default'
+      {
+        current: run_data.current_path,
+        baseline: run_data.baseline_path,
+        diff: @config.diff_dir.join(folder_name, run_data.diff_filename)
+      }
+    end
 
-        FileUtils.mkdir_p(File.dirname(current_path))
-        FileUtils.mkdir_p(File.dirname(diff_path))
+    def capture(driver, run_data, paths, width)
+      driver.resize_window(width || DEFAULT_DRIVER_WIDTH, DEFAULT_DRIVER_HEIGHT)
+      driver.visit(run_data.preview_url)
 
-        driver.save_screenshot(current_path.to_s)
+      FileUtils.mkdir_p(File.dirname(paths[:current]))
+      FileUtils.mkdir_p(File.dirname(paths[:diff]))
 
-        # Trimming (Feature parity with legacy ScreenshotTaker)
-        if File.exist?(current_path)
-          system("convert #{current_path} -trim -bordercolor white -border 10x10 #{current_path}")
-        end
+      driver.save_screenshot(paths[:current].to_s)
+      ImageTrimmer.call(paths[:current].to_s) if File.exist?(paths[:current].to_s)
+    end
 
-        comparator = LookbookVisualTester::ImageComparator.new(
-          baseline_path.to_s,
-          current_path.to_s,
-          diff_path.to_s
-        )
+    def compare_against_baseline(run_data, paths)
+      comparator = ImageComparator.new(paths[:baseline].to_s, paths[:current].to_s, paths[:diff].to_s)
+      result = comparator.call
+      @results << build_result(run_data, paths, result)
+    end
 
-        result = comparator.call
+    def build_result(run_data, paths, result)
+      if result[:error]
+        if result[:error] == 'Baseline not found' || @force_update
+          handle_missing_baseline(run_data, paths)
+        else
+          @output.puts "  [ERROR] #{result[:error]}"
+          Result.new(scenario_name: run_data.name, status: :error, error: result[:error],
+                     baseline_path: paths[:baseline].to_s, current_path: paths[:current].to_s)
+        end
+      elsif result[:mismatch] > 0
+        record_mismatch(run_data, paths, result)
+      else
+        @output.puts '  [PASS] Identical.'
+        Result.new(scenario_name: run_data.name, status: :passed, mismatch: 0.0,
+                   diff_path: paths[:diff].to_s, baseline_path: paths[:baseline].to_s,
+                   current_path: paths[:current].to_s)
+      end
+    end
 
+    def handle_missing_baseline(run_data, paths)
+      if @force_update
+        @output.puts '  [UPDATE] Baseline forced update.'
         status = :passed
-        mismatch = 0.0
-        error = nil
-
-        if result[:error]
-          if result[:error] == 'Baseline not found' || @force_update
-            # First run, maybe auto-approve or just report
-            if @force_update
-              puts '  [UPDATE] Baseline forced update.'
-              status = :passed # Or :updated? Let's use passed for now so it doesn't fail the build
-            else
-              puts '  [NEW] Baseline not found. Saved current as potential baseline.'
-              status = :new
-            end
-            FileUtils.mkdir_p(File.dirname(baseline_path))
-            FileUtils.cp(current_path, baseline_path)
-          else
-            puts "  [ERROR] #{result[:error]}"
-            status = :error
-            error = result[:error]
-          end
-        elsif result[:mismatch] > 0
-          mismatch = result[:mismatch]
-          puts "  [FAIL] Mismatch: #{mismatch.round(2)}%. Diff saved to #{diff_path}"
+      else
+        @output.puts '  [NEW] Baseline not found. Saved current as potential baseline.'
+        status = :new
+      end
+      FileUtils.mkdir_p(File.dirname(paths[:baseline]))
+      FileUtils.cp(paths[:current], paths[:baseline])
+      Result.new(scenario_name: run_data.name, status: status, mismatch: 0.0,
+                 diff_path: nil, baseline_path: paths[:baseline].to_s,
+                 current_path: paths[:current].to_s)
+    end
 
-          # Save DOM snapshot for debugging
-          dom_path = diff_path.sub('.png', '.html')
-          File.write(dom_path, driver.page_source)
-          puts "         DOM Snapshot saved to #{dom_path}"
+    def record_mismatch(run_data, paths, result)
+      mismatch = result[:mismatch]
+      @output.puts "  [FAIL] Mismatch: #{mismatch.round(2)}%. Diff saved to #{paths[:diff]}"
 
-          status = :failed
+      dom_path = paths[:diff].sub('.png', '.html')
+      File.write(dom_path, driver.page_source)
+      @output.puts "         DOM Snapshot saved to #{dom_path}"
 
-          # Clipboard (Feature parity with legacy ScreenshotTaker)
-          if @config.copy_to_clipboard
-            system("xclip -selection clipboard -t image/png -i #{current_path}")
-          end
-        else
-          puts '  [PASS] Identical.'
-          status = :passed
-        end
+      copy_to_clipboard_if_enabled(paths[:current])
 
-        Result.new(
-          scenario_name: run_data.name,
-          status: status,
-          mismatch: mismatch,
-          diff_path: diff_path.to_s,
-          error: error,
-          baseline_path: baseline_path.to_s,
-          current_path: current_path.to_s
-        )
-      rescue StandardError => e
-        puts "  [ERROR] Exception: #{e.message}"
-        puts e.backtrace.take(5)
-        Result.new(
-          scenario_name: run_data.name,
-          status: :error,
-          error: e.message,
-          baseline_path: run_data.baseline_path.to_s,
-          current_path: run_data.current_path.to_s
-        )
-      end
+      Result.new(scenario_name: run_data.name, status: :failed, mismatch: mismatch,
+                 diff_path: paths[:diff].to_s, baseline_path: paths[:baseline].to_s,
+                 current_path: paths[:current].to_s)
+    end
+
+    def copy_to_clipboard_if_enabled(current_path)
+      return unless @config.copy_to_clipboard
+
+      system("xclip -selection clipboard -t image/png -i #{current_path}")
+    end
+
+    def record_failure(run_data, paths, error)
+      @output.puts "  [ERROR] Exception: #{error.message}"
+      @output.puts error.backtrace.take(5)
+      Result.new(scenario_name: run_data.name, status: :error, error: error.message,
+                 baseline_path: paths[:baseline].to_s, current_path: paths[:current].to_s)
+    end
+
+    # Resolves the driver for the current scenario thread, set in run_scenario.
+    def driver
+      Thread.current[:lookbook_visual_tester_driver]
     end
   end
 end

data/lib/lookbook_visual_tester/server_test_runner.rb

@@ -0,0 +1,102 @@
+# lib/lookbook_visual_tester/server_test_runner.rb
+require 'net/http'
+require 'uri'
+require 'timeout'
+require 'tempfile'
+
+module LookbookVisualTester
+  class ServerTestRunner
+    DEFAULT_TEST_TASK = 'lookbook:test'
+    DEFAULT_TIMEOUT = 60
+    POLL_INTERVAL = 0.25
+
+    def self.call(config: LookbookVisualTester.config, timeout: DEFAULT_TIMEOUT, test_task: DEFAULT_TEST_TASK, log_path: nil)
+      new(config: config, timeout: timeout, test_task: test_task, log_path: log_path).call
+    end
+
+    def initialize(config: LookbookVisualTester.config, timeout: DEFAULT_TIMEOUT, test_task: DEFAULT_TEST_TASK, log_path: nil)
+      @config = config
+      @timeout = timeout
+      @test_task = test_task
+      @log_path = log_path
+      @pid = nil
+      @log_file = nil
+    end
+
+    def call
+      validate_host!
+      @pid = spawn_server
+
+      begin
+        self.class.wait_for_server(@config.lookbook_host, timeout: @timeout)
+        puts "[LookbookVisualTester] Server ready at #{@config.lookbook_host}. Running #{@test_task}..."
+
+        task = Rake::Task[@test_task]
+        task.reenable
+        task.invoke
+      ensure
+        stop_server
+      end
+    end
+
+    def self.wait_for_server(host, timeout: DEFAULT_TIMEOUT)
+      uri = URI.parse(host)
+      raise Error, "Invalid lookbook_host: #{host}" unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+
+      Timeout.timeout(timeout) do
+        loop do
+          begin
+            response = Net::HTTP.get_response(uri)
+            return true if response.code.to_i < 500
+          rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, Net::OpenTimeout, Net::ReadTimeout
+            # server not ready yet
+          end
+          sleep POLL_INTERVAL
+        end
+      end
+    rescue Timeout::Error
+      raise Error, "Lookbook server at #{host} did not start within #{timeout}s"
+    end
+
+    private
+
+    def validate_host!
+      host = @config.lookbook_host
+      raise Error, 'lookbook_host must be configured' if host.nil? || host.empty?
+
+      uri = URI.parse(host)
+      raise Error, "Invalid lookbook_host: #{host}" unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+      raise Error, "lookbook_host must include a port: #{host}" unless uri.port
+    end
+
+    def spawn_server
+      port = URI.parse(@config.lookbook_host).port
+      env = {
+        'PORT' => port.to_s,
+        'RAILS_ENV' => ENV.fetch('RAILS_ENV', 'development')
+      }
+      command = ['bundle', 'exec', 'rails', 'server', '-p', port.to_s]
+
+      @log_file = @log_path ? File.open(@log_path, 'w') : Tempfile.create('lookbook_server')
+      Process.spawn(env, *command, out: @log_file, err: @log_file, pgroup: true)
+    end
+
+    def stop_server
+      return unless @pid
+
+      begin
+        Process.kill('-TERM', @pid) # negative pid signals the whole process group
+      rescue Errno::ESRCH
+        # already gone
+      end
+
+      begin
+        Process.waitpid(@pid)
+      rescue Errno::ECHILD
+        # already reaped
+      end
+    ensure
+      @log_file&.close
+    end
+  end
+end

data/lib/lookbook_visual_tester/services/image_trimmer.rb

@@ -0,0 +1,59 @@
+# lib/lookbook_visual_tester/services/image_trimmer.rb
+require 'chunky_png'
+
+module LookbookVisualTester
+  module ImageTrimmer
+    DEFAULT_PADDING = 10
+
+    # Pixels matching any of these colors are considered "empty" border and trimmed.
+    BORDER_COLORS = [
+      ChunkyPNG::Color::WHITE,
+      ChunkyPNG::Color::TRANSPARENT
+    ].freeze
+
+    def self.call(path, padding: DEFAULT_PADDING)
+      image = ChunkyPNG::Image.from_file(path)
+
+      min_x = image.width
+      max_x = -1
+      min_y = image.height
+      max_y = -1
+
+      image.height.times do |y|
+        image.width.times do |x|
+          next if border_pixel?(image[x, y])
+
+          min_x = x if x < min_x
+          max_x = x if x > max_x
+          min_y = y if y < min_y
+          max_y = y if y > max_y
+        end
+      end
+
+      # No content found: keep the original image.
+      return path if max_x < min_x
+
+      content_width = max_x - min_x + 1
+      content_height = max_y - min_y + 1
+      new_width = content_width + (padding * 2)
+      new_height = content_height + (padding * 2)
+
+      trimmed = ChunkyPNG::Image.new(new_width, new_height, ChunkyPNG::Color::TRANSPARENT)
+
+      image.height.times do |y|
+        image.width.times do |x|
+          next if x < min_x || x > max_x || y < min_y || y > max_y
+
+          trimmed[x - min_x + padding, y - min_y + padding] = image[x, y]
+        end
+      end
+
+      trimmed.save(path)
+      path
+    end
+
+    def self.border_pixel?(color)
+      BORDER_COLORS.include?(color)
+    end
+  end
+end

data/lib/lookbook_visual_tester/update_previews.rb

@@ -1,5 +1,4 @@
 require_relative 'service'
-require_relative 'screenshot_taker'
 
 module LookbookVisualTester
   class UpdatePreviews < Service
@@ -12,7 +11,7 @@ module LookbookVisualTester
 
     def update_app_data
       LookbookVisualTester.data[:last_changed_files] = changes.presence || []
-      LookbookVisualTester.data[:last_changed_previews] = previews
+      LookbookVisualTester.data[:last_changed_previews] = selected_previews
     end
 
     def call
@@ -47,8 +46,6 @@ module LookbookVisualTester
 
     def clean_file_name(file)
       file = file.split(components_folder)[-1]
-      # '/' + file.split('/')[-1].split('.')[0]
-      puts ">>>> #{file}"
       file.split('.')[0].gsub('_preview', '')
     end
 
@@ -61,14 +58,8 @@ module LookbookVisualTester
     def process_changes
       Rails.logger.info "LookbookVisualTester: previews #{selected_previews.count}"
       selected_previews.each do |preview|
-        Rails.logger.info "LookbookVisualTester: entering #{preview.inspect}"
-
-        group = preview.respond_to?(:scenarios) ? preview.scenarios : preview.examples
-        group.each do |scenario|
-          scenario_run = LookbookVisualTester::ScenarioRun.new(scenario)
-          Rails.logger.info "LookbookVisualTester: Processing scenario #{scenario_run.inspect}"
-          LookbookVisualTester::ScreenshotTaker.call(scenario_run: scenario_run)
-        end
+        Rails.logger.info "LookbookVisualTester: running Runner for #{preview.inspect}"
+        LookbookVisualTester::Runner.new(pattern: preview.name).run
       end
     end
   end

data/lib/lookbook_visual_tester/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LookbookVisualTester
-  VERSION = '0.5.10'
+  VERSION = '0.7.0'
 end

data/lib/lookbook_visual_tester.rb

@@ -3,6 +3,7 @@
 # lib/lookbook_visual_tester.rb
 
 require_relative 'lookbook_visual_tester/version'
+require_relative 'lookbook_visual_tester/browser_discovery'
 require_relative 'lookbook_visual_tester/configuration'
 require_relative 'lookbook_visual_tester/railtie' if defined?(Rails)
 require_relative 'lookbook_visual_tester/scenario_finder'
@@ -11,6 +12,9 @@ require_relative 'lookbook_visual_tester/runner'
 require_relative 'lookbook_visual_tester/driver'
 require_relative 'lookbook_visual_tester/drivers/ferrum_driver'
 require_relative 'lookbook_visual_tester/services/image_comparator'
+require_relative 'lookbook_visual_tester/services/image_trimmer'
+require_relative 'lookbook_visual_tester/server_test_runner'
+
 
 module LookbookVisualTester
   class Error < StandardError; end