capybara-screenshot-diff 1.1.0 → 1.4.0

data/lib/capybara/screenshot/diff/os.rb

@@ -3,16 +3,16 @@
 module Capybara
   module Screenshot
     module Os
-      ON_WINDOWS = !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
-      ON_MAC = !!(RbConfig::CONFIG['host_os'] =~ /darwin/)
-      ON_LINUX = !!(RbConfig::CONFIG['host_os'] =~ /linux/)
+      ON_WINDOWS = !!(RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/)
+      ON_MAC = !!(RbConfig::CONFIG["host_os"] =~ /darwin/)
+      ON_LINUX = !!(RbConfig::CONFIG["host_os"] =~ /linux/)
 
       def os_name
-        return 'windows' if ON_WINDOWS
-        return 'macos' if ON_MAC
-        return 'linux' if ON_LINUX
+        return "windows" if ON_WINDOWS
+        return "macos" if ON_MAC
+        return "linux" if ON_LINUX
 
-        'unknown'
+        "unknown"
       end
     end
   end

data/lib/capybara/screenshot/diff/stabilization.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'os'
+require_relative "os"
 
 module Capybara
   module Screenshot
@@ -20,16 +20,13 @@ module Stabilization
           }()
         JS
 
-        def take_stable_screenshot(comparison, color_distance_limit:, shift_distance_limit:,
-            area_size_limit:, skip_area:)
-          blurred_input = prepare_page_for_screenshot
+        def take_stable_screenshot(comparison, stability_time_limit:, wait:)
           previous_file_name = comparison.old_file_name
           screenshot_started_at = last_image_change_at = Time.now
+          clean_stabilization_images(comparison.new_file_name)
+
           1.step do |i|
             take_right_size_screenshot(comparison)
-
-            break unless Capybara::Screenshot.stability_time_limit
-
             if comparison.quick_equal?
               clean_stabilization_images(comparison.new_file_name)
               break
@@ -37,12 +34,13 @@ def take_stable_screenshot(comparison, color_distance_limit:, shift_distance_lim
             comparison.reset
 
             if previous_file_name
-              stabilization_comparison =
-                ImageCompare.new(comparison.new_file_name, previous_file_name,
-                    color_distance_limit: color_distance_limit, shift_distance_limit: shift_distance_limit,
-                    area_size_limit: area_size_limit, skip_area: skip_area)
+              stabilization_comparison = make_stabilization_comparison_from(
+                comparison,
+                comparison.new_file_name,
+                previous_file_name
+              )
               if stabilization_comparison.quick_equal?
-                if (Time.now - last_image_change_at) > Capybara::Screenshot.stability_time_limit
+                if (Time.now - last_image_change_at) > stability_time_limit
                   clean_stabilization_images(comparison.new_file_name)
                   break
                 end
@@ -50,48 +48,64 @@ def take_stable_screenshot(comparison, color_distance_limit:, shift_distance_lim
               else
                 last_image_change_at = Time.now
               end
-
-              check_max_wait_time(comparison, screenshot_started_at,
-                  shift_distance_limit: shift_distance_limit)
             end
 
-            previous_file_name = "#{comparison.new_file_name.chomp('.png')}_x#{format('%02i', i)}.png~"
-
+            previous_file_name = "#{comparison.new_file_name.chomp(".png")}" \
+                "_x#{format("%02i", i)}_#{(Time.now - screenshot_started_at).round(1)}s" \
+                "_#{stabilization_comparison.difference_region&.to_s&.gsub(", ", "_") || :initial}.png~"
             FileUtils.mv comparison.new_file_name, previous_file_name
+
+            check_max_wait_time(
+              comparison,
+              screenshot_started_at,
+              max_wait_time: max_wait_time(comparison.shift_distance_limit, wait)
+            )
+          end
+        end
+
+        def notice_how_to_avoid_this
+          unless @_csd_retina_warned
+            warn "Halving retina screenshot.  " \
+                'You should add "force-device-scale-factor=1" to your Chrome chromeOptions args.'
+            @_csd_retina_warned = true
           end
-        ensure
-          blurred_input&.click
         end
 
         private
 
-        def reduce_retina_image_size(file_name)
+        def make_stabilization_comparison_from(comparison, new_file_name, previous_file_name)
+          ImageCompare.new(new_file_name, previous_file_name, **comparison.driver_options)
+        end
+
+        def reduce_retina_image_size(file_name, driver)
           return if !ON_MAC || !selenium? || !Capybara::Screenshot.window_size
 
-          saved_image = ChunkyPNG::Image.from_file(file_name)
-          width = Capybara::Screenshot.window_size[0]
-          return if saved_image.width < width * 2
+          expected_image_width = Capybara::Screenshot.window_size[0]
+          saved_image = driver.from_file(file_name)
+          return if driver.width_for(saved_image) < expected_image_width * 2
 
-          unless @_csd_retina_warned
-            warn 'Halving retina screenshot.  ' \
-                'You should add "force-device-scale-factor=1" to your Chrome chromeOptions args.'
-            @_csd_retina_warned = true
+          notice_how_to_avoid_this
+
+          new_height = expected_image_width * driver.height_for(saved_image) / driver.width_for(saved_image)
+          resized_image = driver.resize_image_to(saved_image, expected_image_width, new_height)
+
+          Dir.mktmpdir do |dir|
+            resized_image_file = "#{dir}/resized.png"
+            driver.save_image_to(resized_image, resized_image_file)
+            FileUtils.mv(resized_image_file, file_name)
           end
-          height = (width * saved_image.height) / saved_image.width
-          resized_image = saved_image.resample_bilinear(width, height)
-          resized_image.save(file_name)
         end
 
         def stabilization_images(base_file)
-          Dir["#{base_file.chomp('.png')}_x*.png~"].sort
+          Dir["#{base_file.chomp(".png")}_x*.png~"].sort
         end
 
         def clean_stabilization_images(base_file)
           FileUtils.rm stabilization_images(base_file)
         end
 
-        def prepare_page_for_screenshot
-          assert_images_loaded
+        def prepare_page_for_screenshot(timeout:)
+          assert_images_loaded(timeout: timeout)
           if Capybara::Screenshot.blur_active_element
             active_element = execute_script(<<-JS)
               ae = document.activeElement;
@@ -103,7 +117,15 @@ def prepare_page_for_screenshot
             JS
             blurred_input = page.driver.send :unwrap_script_result, active_element
           end
-          execute_script("$('*').css('caret-color','transparent')") if Capybara::Screenshot.hide_caret
+          if Capybara::Screenshot.hide_caret && !@hid_caret
+            execute_script(<<~JS)
+              var style = document.createElement('style');
+              document.head.appendChild(style);
+              var styleSheet = style.sheet;
+              styleSheet.insertRule("* { caret-color: transparent !important; }", 0);
+            JS
+            @hid_caret = true
+          end
           blurred_input
         end
 
@@ -111,19 +133,43 @@ def take_right_size_screenshot(comparison)
           save_screenshot(comparison.new_file_name)
 
           # TODO(uwe): Remove when chromedriver takes right size screenshots
-          reduce_retina_image_size(comparison.new_file_name)
+          reduce_retina_image_size(comparison.new_file_name, comparison.driver)
           # ODOT
         end
 
-        def check_max_wait_time(comparison, screenshot_started_at, shift_distance_limit:)
+        def check_max_wait_time(comparison, screenshot_started_at, max_wait_time:)
+          return if (Time.now - screenshot_started_at) < max_wait_time
+
+          annotate_stabilization_images(comparison)
+          # FIXME(uwe): Change to store the failure and only report if the test succeeds functionally.
+          fail("Could not get stable screenshot within #{max_wait_time}s\n" \
+                    "#{stabilization_images(comparison.new_file_name).join("\n")}")
+        end
+
+        def annotate_stabilization_images(comparison)
+          previous_file = comparison.old_file_name
+          stabilization_images(comparison.new_file_name).each do |file_name|
+            if File.exist? previous_file
+              stabilization_comparison = make_stabilization_comparison_from(
+                comparison,
+                file_name,
+                previous_file
+              )
+              if stabilization_comparison.different?
+                FileUtils.mv stabilization_comparison.annotated_new_file_name, file_name
+              end
+              FileUtils.rm stabilization_comparison.annotated_old_file_name
+            end
+            previous_file = file_name
+          end
+        end
+
+        def max_wait_time(shift_distance_limit, wait)
           shift_factor = shift_distance_limit ? (shift_distance_limit * 2 + 1) ^ 2 : 1
-          max_wait_time = Capybara.default_max_wait_time * shift_factor
-          assert((Time.now - screenshot_started_at) < max_wait_time,
-              "Could not get stable screenshot within #{max_wait_time}s\n" \
-                      "#{stabilization_images(comparison.new_file_name).join("\n")}")
+          wait * shift_factor
         end
 
-        def assert_images_loaded(timeout: Capybara.default_max_wait_time)
+        def assert_images_loaded(timeout:)
           return unless respond_to? :evaluate_script
 
           start = Time.now
@@ -131,8 +177,11 @@ def assert_images_loaded(timeout: Capybara.default_max_wait_time)
             pending_image = evaluate_script IMAGE_WAIT_SCRIPT
             break unless pending_image
 
-            assert((Time.now - start) < timeout,
-                "Images not loaded after #{timeout}s: #{pending_image.inspect}")
+            assert(
+              (Time.now - start) < timeout,
+              "Images not loaded after #{timeout}s: #{pending_image.inspect}"
+            )
+
             sleep 0.1
           end
         end

data/lib/capybara/screenshot/diff/test_methods.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'English'
-require 'capybara'
-require 'action_controller'
-require 'action_dispatch'
-require 'active_support/core_ext/string/strip'
-require_relative 'image_compare'
-require_relative 'stabilization'
-require_relative 'vcs'
+require "English"
+require "capybara"
+require "action_controller"
+require "action_dispatch"
+require "active_support/core_ext/string/strip"
+require_relative "image_compare"
+require_relative "stabilization"
+require_relative "vcs"
 
 # Add the `screenshot` method to ActionDispatch::IntegrationTest
 module Capybara
@@ -42,19 +42,13 @@ def screenshot_dir
         end
 
         def current_capybara_driver_class
-          Capybara.drivers[Capybara.current_driver].call({}).class
+          Capybara.current_session.driver.class
         end
 
         def selenium?
           current_capybara_driver_class <= Capybara::Selenium::Driver
         end
 
-        def poltergeist?
-          return false unless defined?(Capybara::Poltergeist::Driver)
-
-          current_capybara_driver_class <= Capybara::Poltergeist::Driver
-        end
-
         def screenshot_section(name)
           @screenshot_section = name.to_s
         end
@@ -68,44 +62,59 @@ def screenshot_group(name)
         end
 
         # @return [Boolean] wether a screenshot was taken
-        def screenshot(name, color_distance_limit: Diff.color_distance_limit,
-            shift_distance_limit: Diff.shift_distance_limit, area_size_limit: Diff.area_size_limit,
-            skip_area: Diff.skip_area)
-          return unless Screenshot.active?
-          return if window_size_is_wrong?
-
-          skip_area = skip_area&.flatten&.each_cons(4)&.to_a # Allow nil or single or multiple areas
+        def screenshot(
+          name,
+          stability_time_limit: Screenshot.stability_time_limit,
+          wait: Capybara.default_max_wait_time,
+          **driver_options
+        )
+          return false unless Screenshot.active?
+          return false if window_size_is_wrong?
+
+          driver_options = {
+            area_size_limit: Diff.area_size_limit,
+            color_distance_limit: Diff.color_distance_limit,
+            driver: Diff.driver,
+            shift_distance_limit: Diff.shift_distance_limit,
+            skip_area: Diff.skip_area,
+            tolerance: Diff.tolerance
+          }.merge(driver_options)
+
+          # Allow nil or single or multiple areas
+          if driver_options[:skip_area]
+            driver_options[:skip_area] = driver_options[:skip_area].compact.flatten&.each_cons(4)&.to_a
+          end
 
           if @screenshot_counter
-            name = "#{format('%02i', @screenshot_counter)}_#{name}"
+            name = "#{format("%02i", @screenshot_counter)}_#{name}"
             @screenshot_counter += 1
           end
           name = full_name(name)
           file_name = "#{Screenshot.screenshot_area_abs}/#{name}.png"
 
           FileUtils.mkdir_p File.dirname(file_name)
-          comparison = ImageCompare.new(file_name,
-              dimensions: Screenshot.window_size, color_distance_limit: color_distance_limit,
-              area_size_limit: area_size_limit, shift_distance_limit: shift_distance_limit,
-              skip_area: skip_area)
+          comparison = ImageCompare.new(file_name, **driver_options)
           checkout_vcs(name, comparison)
-          take_stable_screenshot(comparison, color_distance_limit: color_distance_limit,
-                                             shift_distance_limit: shift_distance_limit,
-                                             area_size_limit: area_size_limit,
-                                             skip_area: skip_area)
-          return unless comparison.old_file_exists?
+          begin
+            blurred_input = prepare_page_for_screenshot(timeout: wait)
+            if stability_time_limit
+              take_stable_screenshot(comparison, stability_time_limit: stability_time_limit, wait: wait)
+            else
+              take_right_size_screenshot(comparison)
+            end
+          ensure
+            blurred_input&.click
+          end
+
+          return false unless comparison.old_file_exists?
 
           (@test_screenshots ||= []) << [caller(1..1).first, name, comparison]
+
           true
         end
 
         def window_size_is_wrong?
           selenium? && Screenshot.window_size &&
-
-            # FIXME(uwe): This happens with headless chrome.  Why?!
-            page.driver.browser.manage.window.size.width &&
-            # EMXIF
-
             page.driver.browser.manage.window.size !=
               ::Selenium::WebDriver::Dimension.new(*Screenshot.window_size)
         end
@@ -113,21 +122,7 @@ def window_size_is_wrong?
         def assert_image_not_changed(caller, name, comparison)
           return unless comparison.different?
 
-          # TODO(uwe): Remove check when we stop supporting Ruby 2.3 and older
-          max_color_distance = if RUBY_VERSION >= '2.4'
-                                 comparison.max_color_distance.ceil(1)
-                               else
-                                 comparison.max_color_distance.ceil
-                               end
-          # ODOT
-
-          max_shift_distance = comparison.max_shift_distance
-          "Screenshot does not match for '#{name}' (area: #{comparison.size}px #{comparison.dimensions}" \
-            ", max_color_distance: #{max_color_distance}" \
-            "#{", max_shift_distance: #{max_shift_distance}" if max_shift_distance})\n" \
-            "#{comparison.new_file_name}\n#{comparison.annotated_old_file_name}\n" \
-            "#{comparison.annotated_new_file_name}\n" \
-            "at #{caller}"
+          "Screenshot does not match for '#{name}' #{comparison.error_message}\nat #{caller}"
         end
       end
     end

data/lib/capybara/screenshot/diff/vcs.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'os'
+require_relative "os"
 module Capybara
   module Screenshot
     module Diff
       module Vcs
-        SILENCE_ERRORS = Os::ON_WINDOWS ? '2>nul' : '2>/dev/null'
+        SILENCE_ERRORS = Os::ON_WINDOWS ? "2>nul" : "2>/dev/null"
 
         def restore_git_revision(name, target_file_name)
           redirect_target = "#{target_file_name} #{SILENCE_ERRORS}"
-          `git show HEAD~0:./#{Capybara::Screenshot.screenshot_area}/#{name}.png > #{redirect_target}`
+          show_command = "git show HEAD~0:./#{Capybara::Screenshot.screenshot_area}/#{name}.png"
+          if Capybara::Screenshot.use_lfs
+            `#{show_command} | git lfs smudge > #{redirect_target}`
+          else
+            `#{show_command} > #{redirect_target}`
+          end
           FileUtils.rm_f(target_file_name) unless $CHILD_STATUS == 0
         end
 

data/lib/capybara/screenshot/diff/version.rb

@@ -3,7 +3,7 @@
 module Capybara
   module Screenshot
     module Diff
-      VERSION = '1.1.0'
+      VERSION = "1.4.0"
     end
   end
 end

data/matrix_test.rb

@@ -1,31 +1,29 @@
 #!/usr/bin/env ruby -w
 # frozen_string_literal: true
 
-system('rubocop --auto-correct') || exit(1)
+update_gemfiles = ARGV.delete("--update")
 
-update_gemfiles = ARGV.delete('--update')
-
-require 'yaml'
-travis = YAML.safe_load(File.read('.travis.yml'))
+require "yaml"
+travis = YAML.safe_load(File.read(".travis.yml"))
 
 def run_script(ruby, env, gemfile)
   env.scan(/\b(?<key>[A-Z_]+)="(?<value>.+?)"/) do |key, value|
     ENV[key] = value
   end
-  puts '*' * 80
+  puts "*" * 80
   puts "Testing #{ruby} #{gemfile} #{env}"
   puts
   system("chruby-exec #{ruby} -- bundle exec rake") || exit(1)
   puts "Testing #{ruby} #{gemfile} OK"
-  puts '*' * 80
+  puts "*" * 80
 end
 
 def use_gemfile(ruby, gemfile, update_gemfiles)
-  puts '$' * 80
-  ENV['BUNDLE_GEMFILE'] = gemfile
+  puts "$" * 80
+  ENV["BUNDLE_GEMFILE"] = gemfile
 
   bundler_version = `grep -A1 "BUNDLED WITH" #{gemfile}.lock | tail -n 1`
-  bundler_version = '~> 2.0' if bundler_version.strip.empty?
+  bundler_version = "~> 2.0" if bundler_version.strip.empty?
 
   version_arg = "-v '#{bundler_version}'"
   bundler_gem_check_cmd = "chruby-exec #{ruby} -- gem query -i -n bundler #{version_arg} >/dev/null"
@@ -37,33 +35,33 @@ def use_gemfile(ruby, gemfile, update_gemfiles)
     system "chruby-exec #{ruby} -- bundle check >/dev/null || chruby-exec #{ruby} -- bundle install"
   end || exit(1)
   yield
-  puts '$' * 80
+  puts "$" * 80
 end
 
-travis['rvm'].each do |ruby|
-  next if ruby =~ /head/ # ruby-install does not support HEAD installation
+travis["rvm"].each do |ruby|
+  next if /head/.match?(ruby) # ruby-install does not support HEAD installation
 
-  puts '#' * 80
+  puts "#" * 80
   puts "Testing #{ruby}"
   puts
   system "ruby-install --no-reinstall #{ruby}" || exit(1)
-  travis['gemfile'].each do |gemfile|
-    if travis['matrix'] &&
-        (travis['matrix']['exclude'].to_a + travis['matrix']['allow_failures'].to_a)
-            .any? { |f| f['rvm'] == ruby && (f['gemfile'].nil? || f['gemfile'] == gemfile) }
-      puts 'Skipping known failure.'
+  travis["gemfile"].each do |gemfile|
+    if travis["matrix"] &&
+        (travis["matrix"]["exclude"].to_a + travis["matrix"]["allow_failures"].to_a)
+            .any? { |f| f["rvm"] == ruby && (f["gemfile"].nil? || f["gemfile"] == gemfile) }
+      puts "Skipping known failure."
       next
     end
     use_gemfile(ruby, gemfile, update_gemfiles) do
-      travis['env'].each do |env|
+      travis["env"].each do |env|
         run_script(ruby, env, gemfile)
       end
     end
   end
   puts "Testing #{ruby} OK"
-  puts '#' * 80
+  puts "#" * 80
 end
 
 print "\033[0;32m"
-print '                        TESTS PASSED OK!'
+print "                        TESTS PASSED OK!"
 puts "\033[0m"