lookbook_visual_tester 0.5.10 → 0.7.0

data/lib/lookbook_visual_tester/browser_discovery.rb

@@ -0,0 +1,31 @@
+# lib/lookbook_visual_tester/browser_discovery.rb
+require 'rbconfig'
+
+module LookbookVisualTester
+  # Finds a usable Chrome/Chromium binary, preferring standard absolute paths
+  # over PATH-resolved lookups. PATH lookup can resolve to wrapper scripts
+  # (e.g. a shell wrapper that injects GPU/Wayland flags) that break headless
+  # Chrome with errors like "Multiple targets are not supported in headless mode".
+  module BrowserDiscovery
+    LINUX_CANDIDATES = %w[
+      /usr/bin/google-chrome-stable
+      /usr/bin/google-chrome
+      /usr/bin/chromium
+      /usr/bin/chromium-browser
+      /opt/google/chrome/google-chrome
+    ].freeze
+
+    MAC_CANDIDATES = %w[
+      /Applications/Google Chrome.app/Contents/MacOS/Google Chrome
+      /Applications/Chromium.app/Contents/MacOS/Chromium
+    ].freeze
+
+    def self.find_binary
+      candidates = case RbConfig::CONFIG['host_os']
+                   when /darwin/ then MAC_CANDIDATES
+                   else LINUX_CANDIDATES
+                   end
+      candidates.find { |path| File.executable?(path) }
+    end
+  end
+end

data/lib/lookbook_visual_tester/configuration.rb

@@ -4,7 +4,8 @@ module LookbookVisualTester
     attr_accessor :lookbook_host, :ui_comparison, :diff_dir, :baseline_dir, :current_dir,
                   :history_dir, :history_keep_last_n, :threads, :copy_to_clipboard,
                   :components_folder, :automatic_run, :mask_selectors, :driver_adapter,
-                  :preview_checker_setup, :logger, :wait_time, :tolerance
+                  :preview_checker_setup, :logger, :wait_time, :tolerance,
+                  :browser_path, :browser_options, :browser_timeout, :process_timeout
 
     DEFAULT_THREADS = 4
 
@@ -21,13 +22,12 @@ module LookbookVisualTester
       @history_dir = @base_path.join('history')
       @threads = ENV.fetch('LOOKBOOK_THREADS', DEFAULT_THREADS).to_i
       @history_keep_last_n = 5
-      @copy_to_clipboard = true
+      @copy_to_clipboard = false
       @components_folder = 'app/components'
-      @automatic_run = ENV.fetch('LOOKBOOK_AUTOMATIC_RUN', false)
+      @automatic_run = ENV.fetch('LOOKBOOK_AUTOMATIC_RUN', 'false') == 'true'
       @mask_selectors = []
       @driver_adapter = :ferrum
       @preview_checker_setup = nil
-      @preview_checker_setup = nil
       @wait_time = 0.5
       @tolerance = 0.0
       @logger = if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
@@ -38,6 +38,13 @@ module LookbookVisualTester
                 end
 
       @lookbook_host = ENV.fetch('LOOKBOOK_HOST', 'http://localhost:5000')
+      # Browser (Ferrum/Chrome) configuration. Defaults target modern Chrome's
+      # `--headless=new` mode; the old `--headless` flag is rejected by current
+      # Chrome builds ("Multiple targets are not supported in headless mode").
+      @browser_path = ENV['LOOKBOOK_BROWSER_PATH'] || LookbookVisualTester::BrowserDiscovery.find_binary
+      @browser_options = { 'headless' => 'new' }
+      @browser_timeout = ENV.fetch('LOOKBOOK_BROWSER_TIMEOUT', '10').to_i
+      @process_timeout = ENV.fetch('LOOKBOOK_PROCESS_TIMEOUT', '10').to_i
     end
 
     def base_path=(value)

data/lib/lookbook_visual_tester/drivers/ferrum_driver.rb

@@ -6,11 +6,15 @@ module LookbookVisualTester
     class FerrumDriver < Driver
       def initialize(config)
         super
-        @browser = Ferrum::Browser.new(
+        browser_opts = {
           headless: true,
-          window_size: [1280, 800], # Default, can be resized
-          timeout: 10 # Configurable?
-        )
+          window_size: [1280, 800],
+          timeout: config.browser_timeout,
+          process_timeout: config.process_timeout,
+          browser_options: config.browser_options
+        }
+        browser_opts[:browser_path] = config.browser_path if config.browser_path
+        @browser = Ferrum::Browser.new(**browser_opts)
       end
 
       def visit(url)

data/lib/lookbook_visual_tester/preview_checker.rb

@@ -16,30 +16,15 @@ module LookbookVisualTester
     end
 
     def deep_check
-      # Ensure custom setup is run before deep checks
       run_setup
-      check_preview_controller_config
       run_checks(:deep_render_check)
     end
 
     def missing
       components_dir = Rails.root.join(@config.components_folder)
-      # Assuming standard structure: test/components/previews for previews
-      # But Lookbook can be configured differently. We should use Lookbook's config if possible to know where previews are.
-      # For now, let's stick to the user's script logic which assumes standard paths or iterate through loaded components.
-
-      # Better approach: Iterate through all known components and check if they have a preview.
-      # However, "all known components" might be hard to get if they aren't loaded.
-      # Let's use the file system approach as in the user script.
+      previews_dir = preview_paths.first
 
       components = Dir.glob(File.join(components_dir, '**', '*_component.rb'))
-      previews_dir = Rails.root.join('test/components/previews') # Default, maybe make configurable?
-
-      # Trying to find where previews are located from Rails config if possible
-      if defined?(Rails) && Rails.application.config.view_component.preview_paths.any?
-        # Use simple heuristic: first path
-        previews_dir = Pathname.new(Rails.application.config.view_component.preview_paths.first)
-      end
 
       missing = []
       components.each do |component_path|
@@ -57,19 +42,22 @@ module LookbookVisualTester
 
     private
 
+    def preview_paths
+      if defined?(Rails) && Rails.application.config.view_component.preview_paths.any?
+        Rails.application.config.view_component.preview_paths.map { |p| Pathname.new(p) }
+      else
+        [Rails.root.join('test/components/previews')]
+      end
+    end
+
+    def run_setup
+      @config.preview_checker_setup&.call
+    end
+
     def run_checks(check_method)
       previews = Lookbook.previews
-      results = []
-
-      # We want to flatten the work items: (PreviewClass, example_name)
-      work_items = []
-      previews.each do |preview|
-        # preview is a Lookbook::Preview object which wraps the class
-        # But for checking we might want the class directly or iterate scenarios
-        examples = preview.scenarios
-        examples.each do |example|
-          work_items << { preview: preview, example: example }
-        end
+      work_items = previews.flat_map do |preview|
+        preview.scenarios.map { |example| { preview: preview, example: example } }
       end
 
       if @config.threads > 1
@@ -82,44 +70,28 @@ module LookbookVisualTester
         results = Concurrent::Promises.zip(*promises).value
         pool.shutdown
         pool.wait_for_termination
+        results
       else
-        results = work_items.map do |item|
-          measure_and_send(item[:preview], item[:example], check_method)
-        end
+        work_items.map { |item| measure_and_send(item[:preview], item[:example], check_method) }
       end
-
-      results
     end
 
     def measure_and_send(preview, example, method_name)
       result = nil
-      time = Benchmark.realtime do
-        result = send(method_name, preview, example)
-      end
+      time = Benchmark.realtime { result = send(method_name, preview, example) }
       result.duration = time
       result
     end
 
     def basic_check(preview, example)
-      # user script logic:
-      # preview_instance = preview_class.new
-      # component = preview_instance.public_send(preview_example)
-      # if component.respond_to?(:render_in) ...
-
-      # Lookbook::Preview wrapper might help, but let's go to the class
       preview_class = preview.preview_class
       example_name = example.name
 
       begin
         preview_instance = preview_class.new
-        unless preview_instance.respond_to?(example_name)
-          return CheckResult.new(preview_name: preview.name, example_name: example_name,
-                                 status: :passed)
-        end
+        return CheckResult.new(preview_name: preview.name, example_name: example_name, status: :passed) unless preview_instance.respond_to?(example_name)
 
         preview_instance.public_send(example_name)
-
-        # We don't render, just verify we can call it.
         CheckResult.new(preview_name: preview.name, example_name: example_name, status: :passed)
       rescue StandardError => e
         CheckResult.new(preview_name: preview.name, example_name: example_name, status: :failed,
@@ -132,82 +104,31 @@ module LookbookVisualTester
       example_name = example.name
 
       begin
-        # Use ViewComponent::Preview logic to get the component to render
-        # This handles the case where the method returns nil (implicit template)
-        # and returns a component that renders the template.
         if preview_class.respond_to?(:preview_example)
           result = preview_class.preview_example(example_name)
-          puts "DEBUG: preview_example('#{example_name}') returned: #{result.inspect} (class: #{result.class})"
         else
-          # Fallback for older VC or non-standard setups
           preview_instance = preview_class.new
-          unless preview_instance.respond_to?(example_name)
-            return CheckResult.new(preview_name: preview.name, example_name: example_name,
-                                   status: :passed)
-          end
+          return CheckResult.new(preview_name: preview.name, example_name: example_name, status: :passed) unless preview_instance.respond_to?(example_name)
           result = preview_instance.public_send(example_name)
         end
 
-        if result.respond_to?(:render_in)
-          # Mock current_user/pundit if needed on the component itself if possible
-          # But mainly we render it with a view context
-          view_context = setup_view_context
+        result = result[:component] if result.is_a?(Hash) && result.key?(:component)
 
-          # Inject mocks into result if it supports it or reliance on global view_context
-          # The user script defines singleton methods on the result.
-          if @mocks
-            @mocks.each do |key, value|
-              if result.respond_to?(key) || !result.respond_to?(key) # Force define
-                result.define_singleton_method(key) { value }
-              end
-            end
-          end
-
-          output = result.render_in(view_context)
+        if result.respond_to?(:render_in)
+          output = result.render_in(build_view_context)
           if output.is_a?(String) && output.include?('ActionView::Template::Error')
-            return CheckResult.new(preview_name: preview.name,
-                                   example_name:,
+            return CheckResult.new(preview_name: preview.name, example_name: example_name,
                                    status: :failed, error: 'ActionView::Template::Error found in rendered output',
                                    backtrace: [])
           end
         elsif result.is_a?(String)
           if result.include?('ActionView::Template::Error')
-            return CheckResult.new(preview_name: preview.name,
-                                   example_name:,
+            return CheckResult.new(preview_name: preview.name, example_name: example_name,
                                    status: :failed, error: 'ActionView::Template::Error found in rendered output',
                                    backtrace: [])
           end
-          # Rendered string, good.
         elsif result.nil?
-          # If result is nil, it implies an implicit template rendering.
-          # We need to verify that the template exists.
-
-          # Try to find the template file based on conventions
-          # Convention: preview_file_dir/preview_file_name/example_name.html.erb
-
-          # We need the preview file path. Lookbook::Preview might not expose it easily
-          # but the class might have source_location.
-
-          method = preview_class.instance_method(example_name)
-          source_file = method.source_location&.first
-
-          found_template = false
-          if source_file
-            dir = File.dirname(source_file)
-            filename = File.basename(source_file, '.rb')
-            template_dir = File.join(dir, filename)
-
-            extensions = ['.html.erb', '.html.haml', '.html.slim']
-            path = File.join(template_dir, "#{example_name}")
-
-            found_template = extensions.any? { |ext| File.exist?("#{path}#{ext}") }
-          end
-
-          unless found_template
-            raise ViewComponent::MissingPreviewTemplateError.new("Preview #{example_name} returned nil and no template found at #{path}.* (checked erb, haml, slim)") if defined?(ViewComponent::MissingPreviewTemplateError)
-
-            raise "Preview returned nil and no template found at #{path}.*"
-          end
+          verify_implicit_template!(preview_class, example_name)
         end
 
         CheckResult.new(preview_name: preview.name, example_name: example_name, status: :passed)
@@ -217,126 +138,35 @@ module LookbookVisualTester
       end
     end
 
-    def check_preview_controller_config
-      return unless defined?(Rails)
-
-      controller_name = Rails.application.config.view_component.preview_controller
-      return unless controller_name
-
-      begin
-        controller_class = controller_name.constantize
-        unless controller_class.action_methods.include?('render_scenario_to_string')
-          puts "WARNING: Configured preview controller '#{controller_name}' does not have 'render_scenario_to_string' action."
-          puts '         This is required for Lookbook to render previews correctly.'
-          puts "         Please ensure your preview controller inherits from 'Lookbook::PreviewController'."
-          # We could raise an error here to fail deep_check
-          raise "Preview Controller '#{controller_name}' missing required action 'render_scenario_to_string'"
-        end
-      rescue NameError
-        puts "WARNING: Configured preview controller '#{controller_name}' could not be loaded."
-        raise "Preview Controller '#{controller_name}' could not be loaded"
-      end
-    end
-
-    def run_setup
-      if @config.preview_checker_setup
-        @config.preview_checker_setup.call
-      else
-        default_setup
-      end
-    end
-
-    def default_setup
-      # Logic from the user's script
-      # We need to set up a controller and view context globally or for use in checks
-
-      # This part is tricky because we need to make these available to the `deep_render_check` method.
-      # We can store the view_context in an instance variable or re-create it.
-
-      # Let's perform the class-level mocks here (User, etc.)
-
-      # Mock User
-      unless defined?(User)
-        # Defining a dummy user if not exists is risky if the app doesn't have User.
-        # But the script assumes User exists or creates a mock.
-        # Let's create a OpenStruct-like mock for typical Devise/Pundit usage.
-      end
-
-      # The script logic:
-      # controller = ApplicationController.new ...
-      # We will do this in `setup_view_context` called per check or once?
-      # `ApplicationController` might not be thread safe if we modify it?
-      # Actually we create a new controller instance.
-
-      # Define @mocks to be injected
-      @mocks = {}
-      @mocks[:current_user] = build_mock_user
-      @mocks[:pundit_user] = @mocks[:current_user]
-    end
-
-    def build_mock_user
-      # Try to load a real user or build a struct
-      if defined?(User) && User.respond_to?(:first) && User.first
-        User.first
-      else
-        # Fallback mock
-        u = Object.new
-        u.define_singleton_method(:email) { 'test@example.com' }
-        u.define_singleton_method(:id) { 1 }
-        # Add other common methods as needed or let them fail/mock dynamic
-        u
-      end
-    end
-
-    def setup_view_context
-      # We need a controller to get a view context
+    def build_view_context
       controller = if defined?(ApplicationController)
                      ApplicationController.new
                    else
                      ActionController::Base.new
                    end
-
       controller.request = ActionDispatch::TestRequest.create
-      if controller.request.env
-        controller.request.env['rack.session'] = {}
-        controller.request.env['rack.session.options'] = { id: SecureRandom.uuid }
-      end
-
-      # Devise mapping
-      if defined?(Devise)
-        controller.request.env['devise.mapping'] = Devise.mappings[:user] if Devise.mappings[:user]
-
-        # Mock warden
-        warden = Object.new
-        warden.define_singleton_method(:authenticate!) { |*| true }
-        warden.define_singleton_method(:authenticate) { |*| true }
-        warden.define_singleton_method(:user) { |*| @mocks[:current_user] }
-        controller.request.env['warden'] = warden
-      end
+      controller.view_context
+    end
 
-      view_context = controller.view_context
+    def verify_implicit_template!(preview_class, example_name)
+      method = preview_class.instance_method(example_name)
+      source_file = method&.source_location&.first
+      return if source_file.nil?
 
-      # Add helper methods to view_context
-      # We can use `class_eval` on the singleton class of the view context
-      vc_singleton = view_context.singleton_class
+      dir = File.dirname(source_file)
+      filename = File.basename(source_file, '.rb')
+      template_dir = File.join(dir, filename)
 
-      if @mocks
-        @mocks.each do |key, value|
-          vc_singleton.send(:define_method, key) { value }
-        end
-      end
+      extensions = ['.html.erb', '.html.haml', '.html.slim']
+      path = File.join(template_dir, example_name)
 
-      # Common auth helpers
-      vc_singleton.send(:define_method, :signed_in?) { true }
+      return if extensions.any? { |ext| File.exist?("#{path}#{ext}") }
 
-      # Pundit policy mock
-      vc_singleton.send(:define_method, :policy) do |_record|
-        Struct.new(:show?, :index?, :create?, :update?, :destroy?, :edit?, :new?, :manage?).new(
-          true, true, true, true, true, true, true, true
-        )
-      end
+      raise ViewComponent::MissingPreviewTemplateError.new(
+        "Preview #{example_name} returned nil and no template found at #{path}.* (checked erb, haml, slim)"
+      ) if defined?(ViewComponent::MissingPreviewTemplateError)
 
-      view_context
+      raise "Preview returned nil and no template found at #{path}.*"
     end
   end
 end

data/lib/lookbook_visual_tester/railtie.rb

@@ -1,8 +1,5 @@
 # lib/lookbook_visual_tester/railtie.rb
 
-# require 'lookbook_visual_tester/capybara_setup'
-require 'lookbook_visual_tester/update_previews'
-
 module LookbookVisualTester
   class Railtie < ::Rails::Railtie
     rake_tasks do
@@ -12,25 +9,22 @@ module LookbookVisualTester
 
     initializer 'LookbookVisualTester.lookbook_after_change' do |_app|
       Rails.logger.info "LookbookVisualTester initialized with host: #{LookbookVisualTester.config.lookbook_host}"
-      Lookbook.after_change do |app, changes|
+      Lookbook.after_change do |_app, changes|
         next unless LookbookVisualTester.config.automatic_run
 
-        # get hash of content of modified files to see if has changed
         modified = changes[:modified]
         my_hash = modified.sort.map { |f| File.read(f) }.hash
 
         lock_file = Rails.root.join('tmp', 'lookbook_visual_tester.lock')
         Rails.logger.info ">>> LookbookVisualTester: No changes detected in #{LookbookVisualTester.data}"
 
-        # Rails.logger.info ">>> LookbookVisualTester: Stack trace: #{caller.join("\n")}"
-        Rails.logger.info ">>> LookbookVisualTester: Changes in #{Rails.cache.instance_variable_get(:@data).keys.inspect}"
         File.open(lock_file, 'w') do |file|
           if file.flock(File::LOCK_EX | File::LOCK_NB)
             if LookbookVisualTester.data[:last_hash] == my_hash
               Rails.logger.info 'LookbookVisualTester: No changes detected in Lookbook'
             else
               LookbookVisualTester.data[:last_hash] = my_hash
-              Rails.logger.info "LookbookVisualTester: Running UpdatePreviews, updattin to #{LookbookVisualTester.data.inspect}"
+              Rails.logger.info "LookbookVisualTester: Running UpdatePreviews, updating to #{LookbookVisualTester.data.inspect}"
               LookbookVisualTester::UpdatePreviews.call(changes)
             end
             file.flock(File::LOCK_UN)