leifcr-capybara-screenshot 1.0.14

data/lib/capybara-screenshot/rspec/json_reporter.rb

@@ -0,0 +1,19 @@
+require 'capybara-screenshot/rspec/base_reporter'
+
+module Capybara
+  module Screenshot
+    module RSpec
+      module JsonReporter
+        extend BaseReporter
+
+        enhance_with_screenshot :format_example
+
+        def format_example_with_screenshot(example)
+          format_example_without_screenshot(example).merge({
+            screenshot: example.metadata[:screenshot]
+          })
+        end
+      end
+    end
+  end
+end

data/lib/capybara-screenshot/rspec/text_reporter.rb

@@ -0,0 +1,39 @@
+require 'capybara-screenshot/rspec/base_reporter'
+require 'capybara-screenshot/helpers'
+
+module Capybara
+  module Screenshot
+    module RSpec
+      module TextReporter
+        extend BaseReporter
+
+        if ::RSpec::Core::Version::STRING.to_i <= 2
+          enhance_with_screenshot :dump_failure_info
+        else
+          enhance_with_screenshot :example_failed
+        end
+
+        def dump_failure_info_with_screenshot(example)
+          dump_failure_info_without_screenshot example
+          output_screenshot_info(example)
+        end
+
+        def example_failed_with_screenshot(notification)
+          example_failed_without_screenshot notification
+          output_screenshot_info(notification.example)
+        end
+
+        private
+        def output_screenshot_info(example)
+          return unless (screenshot = example.metadata[:screenshot])
+          output.puts(long_padding + CapybaraScreenshot::Helpers.yellow("HTML screenshot: file://#{screenshot[:html]}")) if screenshot[:html]
+          output.puts(long_padding + CapybaraScreenshot::Helpers.yellow("Image screenshot: file://#{screenshot[:image]}")) if screenshot[:image]
+        end
+
+        def long_padding
+          "  "
+        end
+      end
+    end
+  end
+end

data/lib/capybara-screenshot/rspec/textmate_link_reporter.rb

@@ -0,0 +1,19 @@
+require 'capybara-screenshot/rspec/base_reporter'
+require 'capybara-screenshot/rspec/html_link_reporter'
+require 'shellwords'
+
+module Capybara
+  module Screenshot
+    module RSpec
+      module TextMateLinkReporter
+        extend BaseReporter
+        include HtmlLinkReporter
+        enhance_with_screenshot :extra_failure_content
+
+        def attributes_for_screenshot_link(url)
+          super.merge("onclick" => "TextMate.system('open #{Shellwords.escape(url)}'); return false;")
+        end
+      end
+    end
+  end
+end

data/lib/capybara-screenshot/rspec.rb

@@ -0,0 +1,95 @@
+require "capybara-screenshot"
+
+require "capybara-screenshot/rspec/text_reporter"
+require "capybara-screenshot/rspec/html_link_reporter"
+require "capybara-screenshot/rspec/html_embed_reporter"
+require "capybara-screenshot/rspec/json_reporter"
+require "capybara-screenshot/rspec/textmate_link_reporter"
+
+module Capybara
+  module Screenshot
+    module RSpec
+
+      # Reporters extend RSpec formatters to display information about screenshots for failed
+      # examples.
+      #
+      # Technically, a reporter is a module that gets injected into a RSpec formatter class.
+      # It uses method aliasing to extend some (usually just one) of the formatter's methods.
+      #
+      # Implementing a custom reporter is as simple as creating a module and setting up the
+      # appropriate aliases. Use `BaseReporter.enhance_with_screenshot` if you don't want
+      # to set up the aliases manually:
+      #
+      #   module MyReporter
+      #     extend Capybara::Screenshot::RSpec::BaseReporter
+      #
+      #     # Will replace the formatter's original `dump_failure_info` method with
+      #     # `dump_failure_info_with_screenshot` from this module:
+      #     enhance_with_screenshot :dump_failure_info
+      #
+      #     def dump_failure_info_with_screenshot(example)
+      #       dump_failure_info_without_screenshot(example) # call original implementation
+      #       ... # your additions here
+      #     end
+      #   end
+      #
+      # Finally customize `Capybara::Screenshot::RSpec::FORMATTERS` to make sure your reporter
+      # gets injected into the appropriate formatter.
+
+      REPORTERS = {
+        "RSpec::Core::Formatters::ProgressFormatter"      => Capybara::Screenshot::RSpec::TextReporter,
+        "RSpec::Core::Formatters::DocumentationFormatter" => Capybara::Screenshot::RSpec::TextReporter,
+        "RSpec::Core::Formatters::HtmlFormatter"          => Capybara::Screenshot::RSpec::HtmlLinkReporter,
+        "RSpec::Core::Formatters::JsonFormatter"          => Capybara::Screenshot::RSpec::JsonReporter,
+        "RSpec::Core::Formatters::TextMateFormatter"      => Capybara::Screenshot::RSpec::TextMateLinkReporter, # RSpec 2
+        "RSpec::Mate::Formatters::TextMateFormatter"      => Capybara::Screenshot::RSpec::TextMateLinkReporter,  # RSpec 3
+        "Fuubar"                                          => Capybara::Screenshot::RSpec::TextReporter
+      }
+
+      class << self
+        attr_accessor :add_link_to_screenshot_for_failed_examples
+
+        def after_failed_example(example)
+          if example.example_group.include?(Capybara::DSL) # Capybara DSL method has been included for a feature we can snapshot
+            Capybara.using_session(Capybara::Screenshot.final_session_name) do
+              if Capybara.page.current_url != '' && Capybara::Screenshot.autosave_on_failure && example.exception
+                filename_prefix = Capybara::Screenshot.filename_prefix_for(:rspec, example)
+
+                saver = Capybara::Screenshot.new_saver(Capybara, Capybara.page, true, filename_prefix)
+                saver.save
+
+                example.metadata[:screenshot] = {}
+                example.metadata[:screenshot][:html]  = saver.html_path if saver.html_saved?
+                example.metadata[:screenshot][:image] = saver.screenshot_path if saver.screenshot_saved?
+              end
+            end
+          end
+        end
+      end
+
+      self.add_link_to_screenshot_for_failed_examples = true
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before do
+    Capybara::Screenshot.final_session_name = nil
+  end
+
+  config.after do |example_from_block_arg|
+    # RSpec 3 no longer defines `example`, but passes the example as block argument instead
+    example = config.respond_to?(:expose_current_running_example_as) ? example_from_block_arg : self.example
+
+    Capybara::Screenshot::RSpec.after_failed_example(example)
+  end
+
+  config.before(:suite) do
+    if Capybara::Screenshot::RSpec.add_link_to_screenshot_for_failed_examples
+      RSpec.configuration.formatters.each do |formatter|
+        next unless (reporter_module = Capybara::Screenshot::RSpec::REPORTERS[formatter.class.to_s])
+        formatter.singleton_class.send :include, reporter_module
+      end
+    end
+  end
+end

data/lib/capybara-screenshot/s3_saver.rb

@@ -0,0 +1,64 @@
+require 'aws-sdk'
+
+module Capybara
+  module Screenshot
+    class S3Saver
+      DEFAULT_REGION = 'us-east-1'
+
+      def initialize(saver, s3_client, bucket_name)
+        @saver = saver
+        @s3_client = s3_client
+        @bucket_name = bucket_name
+      end
+
+      def self.new_with_configuration(saver, configuration)
+        default_s3_client_credentials = {
+          region: DEFAULT_REGION
+        }
+
+        s3_client_credentials = default_s3_client_credentials.merge(
+          configuration.fetch(:s3_client_credentials)
+        )
+
+        s3_client = Aws::S3::Client.new(s3_client_credentials)
+        bucket_name = configuration.fetch(:bucket_name)
+
+        new(saver, s3_client, bucket_name)
+      rescue KeyError
+        raise "Invalid S3 Configuration #{configuration}. Please refer to the documentation for the necessary configurations."
+      end
+
+      def save_and_upload_screenshot
+        save_and do |local_file_path|
+          File.open(local_file_path) do |file|
+            s3_client.put_object(
+                bucket: bucket_name,
+                key: File.basename(local_file_path),
+                body: file
+            )
+          end
+        end
+      end
+      alias_method :save, :save_and_upload_screenshot
+
+      def method_missing(method, *args)
+        # Need to use @saver instead of S3Saver#saver attr_reader method because
+        # using the method goes into infinite loop. Maybe attr_reader implements
+        # its methods via method_missing?
+        @saver.send(method, *args)
+      end
+
+      private
+      attr_reader :saver,
+                  :s3_client,
+                  :bucket_name
+
+      def save_and
+        saver.save
+
+        yield(saver.html_path) if block_given? && saver.html_saved?
+        yield(saver.screenshot_path) if block_given? && saver.screenshot_saved?
+      end
+    end
+  end
+end

data/lib/capybara-screenshot/saver.rb

@@ -0,0 +1,131 @@
+require 'capybara-screenshot/helpers'
+require 'capybara-screenshot/callbacks'
+
+module Capybara
+  module Screenshot
+    class Saver
+      include Capybara::Screenshot::Callbacks
+
+      define_callback :after_save_html
+      define_callback :after_save_screenshot
+
+      attr_reader :capybara, :page, :file_base_name
+
+      def initialize(capybara, page, html_save=true, filename_prefix='screenshot')
+        @capybara, @page, @html_save = capybara, page, html_save
+        time_now = Time.now
+        timestamp = "#{time_now.strftime('%Y-%m-%d-%H-%M-%S.')}#{'%03d' % (time_now.usec/1000).to_i}"
+
+        filename = [filename_prefix]
+        filename << timestamp if Capybara::Screenshot.append_timestamp
+        filename << SecureRandom.hex if Capybara::Screenshot.append_random
+
+        @file_base_name = filename.join('_')
+
+        Capybara::Screenshot.prune
+      end
+
+      def save
+        # if current_path empty then nothing to screen shot as browser has not loaded any URL
+        return if page.current_path.to_s.empty?
+
+        save_html if @html_save
+        save_screenshot
+      end
+
+      def save_html
+        path = html_path
+        clear_save_path do
+          if Capybara::VERSION.match(/^\d+/)[0] == '1'
+            capybara.save_page(page.body, "#{path}")
+          else
+            capybara.save_page("#{path}")
+          end
+        end
+        @html_saved = true
+        run_callbacks :after_save_html, html_path if html_saved?
+      end
+
+      def save_screenshot
+        path = screenshot_path
+        clear_save_path do
+          result = Capybara::Screenshot.registered_drivers.fetch(capybara.current_driver) { |driver_name|
+            warn "capybara-screenshot could not detect a screenshot driver for '#{capybara.current_driver}'. Saving with default with unknown results."
+            Capybara::Screenshot.registered_drivers[:default]
+          }.call(page.driver, path)
+          @screenshot_saved = result != :not_supported
+        end
+        run_callbacks :after_save_screenshot, screenshot_path if screenshot_saved?
+      end
+
+      def html_path
+        File.join(Capybara::Screenshot.capybara_root, "#{file_base_name}.html")
+      end
+
+      def screenshot_path
+        File.join(Capybara::Screenshot.capybara_root, "#{file_base_name}.png")
+      end
+
+      def html_path_alt_root
+        File.join(Capybara::Screenshot.capybara_alt_root, "#{file_base_name}.html")
+      end
+
+      def screenshot_path_alt_root
+        File.join(Capybara::Screenshot.capybara_alt_root, "#{file_base_name}.png")
+      end
+
+      def html_saved?
+        @html_saved
+      end
+
+      def screenshot_saved?
+        @screenshot_saved
+      end
+
+      # If Capybara::Screenshot.capybara_tmp_path is set then
+      # the html_path or screenshot_path can be appended to this path in
+      # some versions of Capybara instead of using it as an absolute path
+      def clear_save_path
+        old_path = Capybara::Screenshot.capybara_tmp_path
+        Capybara::Screenshot.capybara_tmp_path = nil
+        yield
+      ensure
+        Capybara::Screenshot.capybara_tmp_path = old_path
+      end
+
+      def output_screenshot_path
+        output "HTML screenshot: #{html_path_alt_root}" if html_saved?
+        output "Image screenshot: #{screenshot_path_alt_root}" if screenshot_saved?
+      end
+
+      # Print image to screen, if imgcat is available
+      def display_image
+        system("#{imgcat} #{screenshot_path}") unless imgcat.nil?
+      end
+
+      private
+
+      def output(message)
+        puts "    #{CapybaraScreenshot::Helpers.yellow(message)}"
+      end
+
+      def imgcat
+        @imgcat ||= which('imgcat')
+      end
+
+      # Cross-platform way of finding an executable in the $PATH.
+      #
+      #   which('ruby') #=> /usr/bin/ruby
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each { |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          }
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/capybara-screenshot/spinach.rb

@@ -0,0 +1,26 @@
+require "capybara-screenshot"
+
+Spinach.hooks.before_scenario do |scenario|
+  Capybara::Screenshot.final_session_name = nil
+end
+
+module Capybara::Screenshot::Spinach
+  def self.fail_with_screenshot(step_data, exception, location, step_definitions)
+    if Capybara::Screenshot.autosave_on_failure
+      Capybara.using_session(Capybara::Screenshot.final_session_name) do
+        filename_prefix = Capybara::Screenshot.filename_prefix_for(:spinach, step_data)
+        saver = Capybara::Screenshot.new_saver(Capybara, Capybara.page, true, filename_prefix)
+        saver.save
+        saver.output_screenshot_path
+      end
+    end
+  end
+end
+
+Spinach.hooks.on_failed_step do |*args|
+  Capybara::Screenshot::Spinach.fail_with_screenshot(*args)
+end
+
+Spinach.hooks.on_error_step do |*args|
+  Capybara::Screenshot::Spinach.fail_with_screenshot(*args)
+end

data/lib/capybara-screenshot/testunit.rb

@@ -0,0 +1,39 @@
+require 'test/unit/testresult'
+
+module Capybara::Screenshot
+  class << self
+    attr_accessor :testunit_paths
+  end
+
+  self.testunit_paths = [%r{test/integration}]
+end
+
+Test::Unit::TestCase.class_eval do
+  setup do
+    Capybara::Screenshot.final_session_name = nil
+  end
+end
+
+Test::Unit::TestResult.class_eval do
+  private
+
+  def notify_fault_with_screenshot(fault, *args)
+    notify_fault_without_screenshot fault, *args
+    is_integration_test = fault.location.any? do |location|
+      Capybara::Screenshot.testunit_paths.any? { |path| location.match(path) }
+    end
+    if is_integration_test
+      if Capybara::Screenshot.autosave_on_failure
+        Capybara.using_session(Capybara::Screenshot.final_session_name) do
+          filename_prefix = Capybara::Screenshot.filename_prefix_for(:testunit, fault)
+
+          saver = Capybara::Screenshot.new_saver(Capybara, Capybara.page, true, filename_prefix)
+          saver.save
+          saver.output_screenshot_path
+        end
+      end
+    end
+  end
+  alias notify_fault_without_screenshot notify_fault
+  alias notify_fault notify_fault_with_screenshot
+end

data/lib/capybara-screenshot/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Screenshot
+    VERSION = '1.0.14'
+  end
+end