leifcr-capybara-screenshot 1.0.14

data/spec/unit/capybara-screenshot_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Capybara::Screenshot do
+  describe '.register_driver' do
+    before(:all) do
+      @original_drivers = Capybara::Screenshot.registered_drivers.dup
+    end
+
+    after(:all) do
+      Capybara::Screenshot.registered_drivers = @original_drivers
+    end
+
+    it 'stores driver with block' do
+      block = lambda {}
+      Capybara::Screenshot.register_driver :foo, &block
+
+      expect(Capybara::Screenshot.registered_drivers[:foo]).to eql(block)
+    end
+  end
+
+  describe '.register_filename_prefix_formatter' do
+    before(:all) do
+      @original_formatters = Capybara::Screenshot.filename_prefix_formatters.dup
+    end
+
+    after(:all) do
+      Capybara::Screenshot.filename_prefix_formatters = @original_formatters
+    end
+
+    it 'stores test type with block' do
+      block = lambda { |arg| }
+      Capybara::Screenshot.register_filename_prefix_formatter :foo, &block
+
+      expect(Capybara::Screenshot.filename_prefix_formatters[:foo]).to eql(block)
+    end
+
+    describe '.filename_prefix_for' do
+      it 'returns "configured formatter" for specified formatter' do
+        Capybara::Screenshot.register_filename_prefix_formatter(:foo) { |arg| 'custom_path' }
+        expect(Capybara::Screenshot.filename_prefix_for(:foo, double('test'))).to eql('custom_path')
+      end
+    end
+  end
+
+  describe '.filename_prefix_for' do
+    it 'returns "screenshot" for undefined formatter' do
+      expect(Capybara::Screenshot.filename_prefix_for(:foo, double('test'))).to eql('screenshot')
+    end
+  end
+
+  describe '.append_screenshot_path' do
+    it 'prints a deprecation message and delegates to RSpec.add_link_to_screenshot_for_failed_examples' do
+      begin
+        original_stderr = $stderr
+        $stderr = StringIO.new
+        expect {
+          Capybara::Screenshot.append_screenshot_path = false
+        }.to change {
+          Capybara::Screenshot::RSpec.add_link_to_screenshot_for_failed_examples
+        }.from(true).to(false)
+        expect($stderr.string).to include("append_screenshot_path is deprecated")
+      ensure
+        $stderr = original_stderr
+      end
+    end
+  end
+
+  describe '.new_saver' do
+    it 'passes through to get a new Saver if the user has not configured s3' do
+      saver_double = double('saver')
+      args = double('args')
+      expect(Capybara::Screenshot::Saver).to receive(:new).with(args).and_return(saver_double)
+
+      expect(Capybara::Screenshot.new_saver(args)).to eq(saver_double)
+    end
+
+    it 'wraps the returned saver in an S3 saver if it has been configured' do
+      require 'capybara-screenshot/s3_saver'
+
+      saver_double = double('saver')
+      args = double('args')
+      s3_saver_double = double('s3_saver')
+      s3_configuration = { hello: 'world' }
+
+      Capybara::Screenshot.s3_configuration = s3_configuration
+
+      expect(Capybara::Screenshot::Saver).to receive(:new).with(args).and_return(saver_double)
+      expect(Capybara::Screenshot::S3Saver).to receive(:new_with_configuration).with(saver_double, s3_configuration).and_return(s3_saver_double)
+
+      expect(Capybara::Screenshot.new_saver(args)).to eq(s3_saver_double)
+    end
+  end
+
+  describe '#prune' do
+    before do
+      Capybara::Screenshot.reset_prune_history
+    end
+
+    it 'prunes once by default' do
+      expect(Capybara::Screenshot::Pruner).to receive(:new).and_call_original.once
+      3.times { Capybara::Screenshot.prune }
+    end
+
+    it 'prunes every time if option force: true' do
+      expect(Capybara::Screenshot::Pruner).to receive(:new).and_call_original.exactly(3).times
+      3.times { Capybara::Screenshot.prune(force: true) }
+    end
+
+    context 'prune strategy' do
+      let(:prune_strategy) { { keep: 100 } }
+      before do
+        Capybara::Screenshot.prune_strategy = prune_strategy
+      end
+
+      it 'is passed to initializer' do
+        expect(Capybara::Screenshot::Pruner).to receive(:new).with(prune_strategy).and_call_original
+        Capybara::Screenshot.prune
+      end
+    end
+  end
+end

data/spec/unit/capybara_spec.rb

@@ -0,0 +1,50 @@
+require 'capybara-screenshot'
+require 'capybara/dsl'
+
+describe Capybara do
+  it 'adds screen shot methods to the Capybara module' do
+    expect(::Capybara).to respond_to(:screenshot_and_save_page)
+    expect(::Capybara).to respond_to(:screenshot_and_open_image)
+  end
+
+  context 'request type example', :type => :request do
+    it 'has access to screen shot instance methods' do
+      expect(subject).to respond_to(:screenshot_and_save_page)
+      expect(subject).to respond_to(:screenshot_and_open_image)
+    end
+  end
+
+  describe 'using_session' do
+    include Capybara::DSL
+
+    it 'saves the name of the final session' do
+      expect(Capybara::Screenshot).to receive(:final_session_name=).with(:different_session)
+      expect {
+        using_session :different_session do
+          expect(0).to eq 1
+        end
+      }.to raise_exception ::RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+end
+
+describe 'final_session_name' do
+  subject { Capybara::Screenshot.clone }
+
+  describe 'when the final session name has been set' do
+    before do
+      subject.final_session_name = 'my-failing-session'
+    end
+
+    it 'returns the name' do
+      expect(subject.final_session_name).to eq 'my-failing-session'
+    end
+  end
+
+  describe 'when the final session name has not been set' do
+    it 'returns the current session name' do
+      allow(Capybara).to receive(:session_name).and_return('my-current-session')
+      expect(subject.final_session_name).to eq 'my-current-session'
+    end
+  end
+end

data/spec/unit/pruner_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Capybara::Screenshot::Pruner do
+  describe '#initialize' do
+    let(:pruner) { Capybara::Screenshot::Pruner.new(strategy) }
+
+    context 'accepts generic strategies:' do
+      [:keep_all, :keep_last_run].each do |strategy_sym|
+        let(:strategy) { strategy_sym }
+
+        it ":#{strategy_sym}" do
+          expect(pruner.strategy).to eq(strategy)
+        end
+      end
+    end
+
+    context 'keep:int' do
+      let(:strategy) { { keep: 50 } }
+
+      it 'is a suitable strategy' do
+        expect(pruner.strategy).to eq(strategy)
+      end
+    end
+
+    context 'invalid strategy' do
+      context 'symbol' do
+        let(:strategy) { :invalid_strategy }
+
+        it 'raises an error' do
+          expect { pruner }.to raise_error(/Invalid prune strategy/)
+        end
+      end
+
+      context 'keep:sym' do
+        let(:strategy) { { keep: :symbol } }
+
+        it 'raises an error' do
+          expect { pruner }.to raise_error(/must be a Integer/)
+        end
+      end
+    end
+  end
+
+  describe '#prune_old_screenshots' do
+    let(:capybara_root)   { Capybara::Screenshot.capybara_root }
+    let(:remaining_files) { Dir.glob(File.expand_path('*', capybara_root)).sort }
+    let(:files_created)   { [] }
+    let(:files_count)     { 8 }
+    let(:pruner)         { Capybara::Screenshot::Pruner.new(strategy) }
+
+    before do
+      allow(Capybara::Screenshot).to receive(:capybara_root).and_return(Dir.mktmpdir.to_s)
+
+      files_count.times do |i|
+        files_created << FileUtils.touch("#{capybara_root}/#{i}.#{i % 2 == 0 ? 'png' : 'html'}").first.tap do |file_name|
+          File.utime(Time.now, Time.now - files_count + i, file_name)
+        end
+      end
+
+      pruner.prune_old_screenshots
+    end
+
+    after do
+      FileUtils.rm_rf capybara_root
+    end
+
+    context 'with :keep_all strategy' do
+      let(:strategy) { :keep_all }
+
+      it 'should not remove screens' do
+        expect(remaining_files).to eq(files_created)
+      end
+    end
+
+    context 'with :keep_last_run strategy' do
+      let(:strategy) { :keep_last_run }
+
+      it 'should remove all screens' do
+        expect(remaining_files).to be_empty
+      end
+
+      context 'when dir is missing' do
+        before { FileUtils.rm_rf(Capybara::Screenshot.capybara_root) }
+
+        it 'should not raise error' do
+          expect { pruner.prune_old_screenshots }.to_not raise_error
+        end
+      end
+    end
+
+    context 'with :keep strategy' do
+      let(:keep_count) { 3 }
+      let(:strategy) { { keep: keep_count } }
+
+      it 'should keep specified number of screens' do
+        expect(remaining_files).to eq(files_created.last(keep_count))
+      end
+
+      context 'when dir is missing' do
+        before { FileUtils.rm_rf(Capybara::Screenshot.capybara_root) }
+
+        it 'should not raise error when dir is missing' do
+          expect { pruner.prune_old_screenshots }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/unit/rspec_reporters/html_embed_reporter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Capybara::Screenshot::RSpec::HtmlEmbedReporter do
+  include_context 'html reporter'
+
+  context 'when an image was saved' do
+    before do
+      set_example double("example", metadata: {screenshot: {image: "path/to/image"}})
+    end
+
+    it 'embeds the image base64 encoded into the content' do
+      expect(File).to receive(:binread).with("path/to/image").and_return("image data")
+      encoded_image_data = Base64.encode64('image data')
+      content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style='.*?' ?/, "")
+      expect(content_without_styles).to eql("original content<img src='data:image/png;base64,#{encoded_image_data}'>")
+    end
+  end
+end

data/spec/unit/rspec_reporters/html_link_reporter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Capybara::Screenshot::RSpec::HtmlLinkReporter do
+  include_context 'html reporter'
+
+  context 'when a html file was saved' do
+    before do
+      set_example double("example", metadata: {screenshot: {html: "path/to/a html file"}})
+    end
+
+    it 'appends a link to the html to the original content' do
+      content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style=".*?" ?/, "")
+      expect(content_without_styles).to eql(%{original content<p>Saved files: <a href="file://path/to/a%20html%20file">HTML page</a></p>})
+    end
+  end
+
+  context 'when a html file and an image were saved' do
+    before do
+      set_example double("example", metadata: {screenshot: {html: "path/to/html", image: "path/to/an image"}})
+    end
+
+    it 'appends links to both files to the original content' do
+      content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style=".*?" ?/, "")
+      expect(content_without_styles).to eql(%{original content<p>Saved files: <a href="file://path/to/html">HTML page</a><a href="file://path/to/an%20image">Screenshot</a></p>})
+    end
+  end
+end

data/spec/unit/rspec_reporters/text_reporter_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'capybara-screenshot/helpers'
+
+describe Capybara::Screenshot::RSpec::TextReporter do
+  before do
+    # Mocking `RSpec::Core::Formatters::ProgressFormatter`, but only implementing the methods that
+    # are actually used in `TextReporter#dump_failure_info_with_screenshot`.
+    @reporter_class = Class.new do
+      attr_reader :output
+
+      def initialize
+        @output = StringIO.new
+      end
+
+      protected
+
+      def long_padding
+        "  "
+      end
+
+      def failure_color(str)
+        "colorized(#{str})"
+      end
+
+      private
+
+      def dump_failure_info(example)
+        output.puts "original failure info"
+      end
+      alias_method :example_failed, :dump_failure_info
+    end
+
+    @reporter = @reporter_class.new
+    @reporter.singleton_class.send :include, described_class
+  end
+
+  let(:example_failed_method) do
+    if ::RSpec::Core::Version::STRING.to_i <= 2
+      :dump_failure_info
+    else
+      :example_failed
+    end
+  end
+
+  def example_failed_method_argument_double(metadata = {})
+    example_group = Module.new.send(:include, Capybara::DSL)
+    example = double("example", metadata: metadata, example_group: example_group)
+    if ::RSpec::Core::Version::STRING.to_i <= 2
+      example
+    else
+      double("notification").tap do |notification|
+        allow(notification).to receive(:example).and_return(example)
+      end
+    end
+  end
+
+  context 'when there is no screenshot' do
+    let(:example) { example_failed_method_argument_double }
+
+    it 'doesnt change the original output of the reporter' do
+      @reporter.send(example_failed_method, example)
+      expect(@reporter.output.string).to eql("original failure info\n")
+    end
+  end
+
+  context 'when a html file was saved' do
+    let(:example) { example_failed_method_argument_double(screenshot: { html: "path/to/html" }) }
+
+    it 'appends the html file path to the original output' do
+      @reporter.send(example_failed_method, example)
+      expect(@reporter.output.string).to eql("original failure info\n  #{CapybaraScreenshot::Helpers.yellow("HTML screenshot: file://path/to/html")}\n")
+    end
+  end
+
+  context 'when a html file and an image were saved' do
+    let(:example) { example_failed_method_argument_double(screenshot: { html: "path/to/html", image: "path/to/image" }) }
+
+    it 'appends the image path to the original output' do
+      @reporter.send(example_failed_method, example)
+      expect(@reporter.output.string).to eql("original failure info\n  #{CapybaraScreenshot::Helpers.yellow("HTML screenshot: file://path/to/html")}\n  #{CapybaraScreenshot::Helpers.yellow("Image screenshot: file://path/to/image")}\n")
+    end
+  end
+
+
+  it 'works with older RSpec formatters where `#red` is used instead of `#failure_color`' do
+    old_reporter_class = Class.new(@reporter_class) do
+      undef_method :failure_color
+      def red(str)
+        "red(#{str})"
+      end
+    end
+    old_reporter = old_reporter_class.new
+    old_reporter.singleton_class.send :include, described_class
+    example = example_failed_method_argument_double(screenshot: { html: "path/to/html" })
+    old_reporter.send(example_failed_method, example)
+    expect(old_reporter.output.string).to eql("original failure info\n  #{CapybaraScreenshot::Helpers.yellow("HTML screenshot: file://path/to/html")}\n")
+  end
+end

data/spec/unit/rspec_reporters/textmate_link_reporter_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Capybara::Screenshot::RSpec::TextMateLinkReporter do
+  include_context 'html reporter'
+
+  context 'when a html file was saved' do
+    before do
+      set_example double("example", metadata: {screenshot: {html: "path/to/a html file"}})
+    end
+
+    it 'appends a link to the html to the original content' do
+      content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style=".*?"/, "")
+      # Single quotes are handled differently by CGI.escape_html in Ruby 1.9 / Ruby 2, so to be
+      # compatible with both versions we can't hard code the final escaped string.
+      expected_onclick_handler = CGI.escape_html("TextMate.system('open file://path/to/a\\%20html\\%20file'); return false;")
+      expect(content_without_styles).to eql(%{original content<p>} +
+        %{Saved files: <a href="file://path/to/a%20html%20file" onclick="#{expected_onclick_handler}">HTML page</a></p>}
+      )
+    end
+  end
+
+  context 'when a html file and an image were saved' do
+    before do
+      set_example double("example", metadata: {screenshot: {html: "path/to/html", image: "path/to/an image"}})
+    end
+
+    it 'appends links to both files to the original content' do
+      content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style=".*?"/, "")
+      # Single quotes are handled differently by CGI.escape_html in Ruby 1.9 / Ruby 2, so to be
+      # compatible with both versions we can't hard code the final escaped string.
+      expected_onclick_handler_1 = CGI.escape_html("TextMate.system('open file://path/to/html'); return false;")
+      expected_onclick_handler_2 = CGI.escape_html("TextMate.system('open file://path/to/an\\%20image'); return false;")
+      expect(content_without_styles).to eql(%{original content<p>} +
+        %{Saved files: <a href="file://path/to/html" onclick="#{expected_onclick_handler_1}">HTML page</a>} +
+        %{<a href="file://path/to/an%20image" onclick="#{expected_onclick_handler_2}">Screenshot</a></p>}
+      )
+    end
+  end
+end