capybara-screenshot 0.3.22 → 1.0.0

data/spec/support/html_reporter_context.rb

@@ -22,7 +22,7 @@ shared_context 'html reporter' do
     end
 
     it 'doesnt change the original content of the reporter' do
-      @reporter.extra_failure_content(nil).should == "original content"
+      expect(@reporter.extra_failure_content(nil)).to eql("original content")
     end
   end
 end

data/spec/support/test_app.rb

@@ -0,0 +1,13 @@
+require 'sinatra/base'
+
+Sinatra::Application.root = '.'
+
+class TestApp < Sinatra::Base
+  get '/' do
+    'This is the root page'
+  end
+
+  get '/different_page' do
+    'This is a different page'
+  end
+end

data/spec/{rspec → unit}/base_reporter_spec.rb

@@ -17,9 +17,9 @@ describe Capybara::Screenshot::RSpec::BaseReporter do
         end
       end
 
-      klass.new.foo.should == :original
+      expect(klass.new.foo).to eql(:original)
       klass.send :include, reporter_module
-      klass.new.foo.should == [:original, :enhanced]
+      expect(klass.new.foo).to eql([:original, :enhanced])
     end
   end
 end

data/spec/{rspec_spec.rb → unit/capybara-screenshot_rspec_spec.rb}

@@ -4,38 +4,43 @@ describe Capybara::Screenshot::RSpec do
   describe '.after_failed_example' do
     context 'for a failed example in a feature that can be snapshotted' do
       before do
-        Capybara.page.stub(save_page: nil, current_url: "http://test.local")
-        Capybara::Screenshot::Saver.stub(new: mock_saver)
+        allow(Capybara.page).to receive(:save_page)
+        allow(Capybara.page).to receive(:current_url).and_return("http://test.local")
+        allow(Capybara::Screenshot::Saver).to receive(:new).and_return(mock_saver)
       end
       let(:example) { double("example", exception: Exception.new, metadata: {}) }
-      let(:mock_saver) { Capybara::Screenshot::Saver.new(Capybara, Capybara.page).tap { |saver| saver.stub(:save) } }
+      let(:mock_saver) do
+        Capybara::Screenshot::Saver.new(Capybara, Capybara.page).tap do |saver|
+          allow(saver).to receive(:save)
+        end
+      end
 
       it 'instantiates a saver and calls `save` on it' do
-        mock_saver.should_receive(:save)
+        expect(mock_saver).to receive(:save)
         described_class.after_failed_example(example)
       end
 
       it 'extends the metadata with an empty hash for screenshot metadata' do
         described_class.after_failed_example(example)
-        example.metadata.should have_key(:screenshot)
-        example.metadata[:screenshot].should == {}
+        expect(example.metadata).to have_key(:screenshot)
+        expect(example.metadata[:screenshot]).to eql({})
       end
 
       context 'when a html file gets saved' do
-        before { mock_saver.stub(:html_saved? => true) }
+        before { allow(mock_saver).to receive(:html_saved?).and_return(true) }
 
         it 'adds the html file path to the screenshot metadata' do
           described_class.after_failed_example(example)
-          example.metadata[:screenshot][:html].should start_with("./screenshot")
+          expect(example.metadata[:screenshot][:html]).to match("./screenshot")
         end
       end
 
       context 'when an image gets saved' do
-        before { mock_saver.stub(:screenshot_saved? => true) }
+        before { allow(mock_saver).to receive(:screenshot_saved?).and_return(true) }
 
         it 'adds the image path to the screenshot metadata' do
           described_class.after_failed_example(example)
-          example.metadata[:screenshot][:image].should start_with("./screenshot")
+          expect(example.metadata[:screenshot][:image]).to match("./screenshot")
         end
       end
     end

data/spec/{capybara-screenshot_spec.rb → unit/capybara-screenshot_spec.rb}

@@ -10,11 +10,11 @@ describe Capybara::Screenshot do
       Capybara::Screenshot.registered_drivers = @original_drivers
     end
 
-    it 'should store driver with block' do
+    it 'stores driver with block' do
       block = lambda {}
       Capybara::Screenshot.register_driver :foo, &block
 
-      Capybara::Screenshot.registered_drivers[:foo].should eq block
+      expect(Capybara::Screenshot.registered_drivers[:foo]).to eql(block)
     end
   end
 
@@ -27,17 +27,17 @@ describe Capybara::Screenshot do
       Capybara::Screenshot.filename_prefix_formatters = @original_formatters
     end
 
-    it 'should store test type with block' do
+    it 'stores test type with block' do
       block = lambda { |arg| }
       Capybara::Screenshot.register_filename_prefix_formatter :foo, &block
 
-      Capybara::Screenshot.filename_prefix_formatters[:foo].should eq block
+      expect(Capybara::Screenshot.filename_prefix_formatters[:foo]).to eql(block)
     end
   end
 
   describe ".filename_prefix_for" do
-    it 'should return "screenshot" for undefined formatter' do
-      Capybara::Screenshot.filename_prefix_for(:foo, double('test')).should eq 'screenshot'
+    it 'returns "screenshot" for undefined formatter' do
+      expect(Capybara::Screenshot.filename_prefix_for(:foo, double('test'))).to eql('screenshot')
     end
   end
 
@@ -51,10 +51,10 @@ describe Capybara::Screenshot do
         }.to change {
           Capybara::Screenshot::RSpec.add_link_to_screenshot_for_failed_examples
         }.from(true).to(false)
-        $stderr.string.should include("append_screenshot_path is deprecated")
+        expect($stderr.string).to include("append_screenshot_path is deprecated")
       ensure
         $stderr = original_stderr
       end
     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/{rspec → unit/rspec_reporters}/html_embed_reporter_spec.rb

@@ -9,10 +9,10 @@ describe Capybara::Screenshot::RSpec::HtmlEmbedReporter do
     end
 
     it 'embeds the image base64 encoded into the content' do
-      File.should_receive(:binread).with("path/to/image").and_return("image data")
+      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='.*?' ?/, "")
-      content_without_styles.should == "original content<img src='data:image/png;base64,#{encoded_image_data}'>"
+      expect(content_without_styles).to eql("original content<img src='data:image/png;base64,#{encoded_image_data}'>")
     end
   end
 end

data/spec/{rspec → unit/rspec_reporters}/html_link_reporter_spec.rb

@@ -10,7 +10,7 @@ describe Capybara::Screenshot::RSpec::HtmlLinkReporter do
 
     it 'appends a link to the html to the original content' do
       content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style=".*?" ?/, "")
-      content_without_styles.should == %{original content<p>Saved files: <a href="file://path/to/a%20html%20file">HTML page</a></p>}
+      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
 
@@ -21,7 +21,7 @@ describe Capybara::Screenshot::RSpec::HtmlLinkReporter do
 
     it 'appends links to both files to the original content' do
       content_without_styles = @reporter.extra_failure_content(nil).gsub(/ ?style=".*?" ?/, "")
-      content_without_styles.should == %{original content<p>Saved files: <a href="file://path/to/html">HTML page</a><a href="file://path/to/an%20image">Screenshot</a></p>}
+      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,96 @@
+require 'spec_helper'
+
+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::Version::STRING.to_i <= 2
+      :dump_failure_info
+    else
+      :example_failed
+    end
+  end
+
+  def example_failed_method_argument_double(metadata = {})
+    example = double("example", metadata: metadata)
+    if ::RSpec::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  #{"HTML screenshot: path/to/html".yellow}\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  #{"HTML screenshot: path/to/html".yellow}\n  #{"Image screenshot: path/to/image".yellow}\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  #{"HTML screenshot: path/to/html".yellow}\n")
+  end
+end

data/spec/{rspec → unit/rspec_reporters}/textmate_link_reporter_spec.rb

@@ -13,8 +13,9 @@ describe Capybara::Screenshot::RSpec::TextMateLinkReporter do
       # 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;")
-      content_without_styles.should == %{original content<p>} +
+      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
 
@@ -29,9 +30,10 @@ describe Capybara::Screenshot::RSpec::TextMateLinkReporter do
       # 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;")
-      content_without_styles.should == %{original content<p>} +
+      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
+end

data/spec/unit/saver_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe Capybara::Screenshot::Saver do
+  before(:all) do
+    @original_drivers = Capybara::Screenshot.registered_drivers
+    Capybara::Screenshot.registered_drivers[:default] = lambda {|driver, path| driver.render(path) }
+  end
+
+  after(:all) do
+    Capybara::Screenshot.registered_drivers = @original_drivers
+  end
+
+  before do
+    allow(Capybara::Screenshot).to receive(:capybara_root).and_return(capybara_root)
+    Timecop.freeze(Time.local(2012, 6, 7, 8, 9, 10, 0))
+  end
+
+  let(:capybara_root) { '/tmp' }
+  let(:timestamp) { '2012-06-07-08-09-10.000' }
+  let(:file_basename) { "screenshot_#{timestamp}" }
+  let(:screenshot_path) { "#{capybara_root}/#{file_basename}.png" }
+
+  let(:driver_mock) { double('Capybara driver').as_null_object }
+  let(:page_mock) { double('Capybara session page', :body => 'body', :driver => driver_mock).as_null_object }
+  let(:capybara_mock) {
+    double(Capybara).as_null_object.tap do |m|
+      allow(m).to receive(:current_driver).and_return(:default)
+      allow(m).to receive(:current_path).and_return('/')
+    end
+  }
+
+  let(:saver) { Capybara::Screenshot::Saver.new(capybara_mock, page_mock) }
+
+  context 'html filename with Capybara Version 1' do
+    before do
+      stub_const("Capybara::VERSION", '1')
+    end
+
+    it 'has a default format of "screenshot_Y-M-D-H-M-S.ms.html"' do
+      expect(capybara_mock).to receive(:save_page).with('body', File.join(capybara_root, "#{file_basename}.html"))
+
+      saver.save
+    end
+
+    it 'uses name argument as prefix' do
+      saver = Capybara::Screenshot::Saver.new(capybara_mock, page_mock, true, 'custom-prefix')
+
+      expect(capybara_mock).to receive(:save_page).with('body', File.join(capybara_root, "custom-prefix_#{timestamp}.html"))
+
+      saver.save
+    end
+  end
+
+  context 'html filename with Capybara Version 2' do
+    before do
+      stub_const("Capybara::VERSION", '2')
+    end
+
+    it 'has a default format of "screenshot_Y-M-D-H-M-S.ms.html"' do
+      expect(capybara_mock).to receive(:save_page).with(File.join(capybara_root, "#{file_basename}.html"))
+
+      saver.save
+    end
+
+    it 'uses name argument as prefix' do
+      saver = Capybara::Screenshot::Saver.new(capybara_mock, page_mock, true, 'custom-prefix')
+
+      expect(capybara_mock).to receive(:save_page).with(File.join(capybara_root, "custom-prefix_#{timestamp}.html"))
+
+      saver.save
+    end
+  end
+
+  context 'screenshot image path' do
+    it 'is in capybara root output' do
+      expect(driver_mock).to receive(:render).with(/^#{capybara_root}\//)
+
+      saver.save
+    end
+
+    it 'has a default filename format of "screenshot_Y-M-D-H-M-S.ms.png"' do
+      expect(driver_mock).to receive(:render).with(/#{file_basename}\.png$/)
+
+      saver.save
+    end
+
+    it "does not append timestamp if append_timestamp is false " do
+      default_config = Capybara::Screenshot.append_timestamp
+      Capybara::Screenshot.append_timestamp = false
+      expect(driver_mock).to receive(:render).with(/screenshot.png$/)
+
+      saver.save
+      Capybara::Screenshot.append_timestamp = default_config
+    end
+
+    it 'uses filename prefix argument as basename prefix' do
+      saver = Capybara::Screenshot::Saver.new(capybara_mock, page_mock, true, 'custom-prefix')
+      expect(driver_mock).to receive(:render).with(/#{capybara_root}\/custom-prefix_#{timestamp}\.png$/)
+
+      saver.save
+    end
+  end
+
+  it 'does not save html if false passed as html argument' do
+    saver = Capybara::Screenshot::Saver.new(capybara_mock, page_mock, false)
+    expect(capybara_mock).to_not receive(:save_page)
+
+    saver.save
+    expect(saver).to_not be_html_saved
+  end
+
+  it 'does not save if current_path is empty' do
+    allow(capybara_mock).to receive(:current_path).and_return(nil)
+    expect(capybara_mock).to_not receive(:save_page)
+    expect(driver_mock).to_not receive(:render)
+
+    saver.save
+    expect(saver).to_not be_screenshot_saved
+    expect(saver).to_not be_html_saved
+  end
+
+  describe '#output_screenshot_path' do
+    let(:saver) { Capybara::Screenshot::Saver.new(capybara_mock, page_mock) }
+
+    before do
+      allow(saver).to receive(:html_path) { 'page.html' }
+      allow(saver).to receive(:screenshot_path) { 'screenshot.png' }
+    end
+
+    it 'outputs the path for the HTML screenshot' do
+      allow(saver).to receive(:html_saved?).and_return(true)
+      expect(saver).to receive(:output).with("HTML screenshot: page.html")
+      saver.output_screenshot_path
+    end
+
+    it 'outputs the path for the Image screenshot' do
+      allow(saver).to receive(:screenshot_saved?).and_return(true)
+      expect(saver).to receive(:output).with("Image screenshot: screenshot.png")
+      saver.output_screenshot_path
+    end
+  end
+
+  describe "with selenium driver" do
+    before do
+      allow(capybara_mock).to receive(:current_driver).and_return(:selenium)
+    end
+
+    it 'saves via browser' do
+      browser_mock = double('browser')
+      expect(driver_mock).to receive(:browser).and_return(browser_mock)
+      expect(browser_mock).to receive(:save_screenshot).with(screenshot_path)
+
+      saver.save
+      expect(saver).to be_screenshot_saved
+    end
+  end
+
+  describe "with poltergeist driver" do
+    before do
+      allow(capybara_mock).to receive(:current_driver).and_return(:poltergeist)
+    end
+
+    it 'saves driver render with :full => true' do
+      expect(driver_mock).to receive(:render).with(screenshot_path, {:full => true})
+
+      saver.save
+      expect(saver).to be_screenshot_saved
+    end
+  end
+
+  describe "with webkit driver" do
+    before do
+      allow(capybara_mock).to receive(:current_driver).and_return(:webkit)
+    end
+
+    context 'has render method' do
+      before do
+        allow(driver_mock).to receive(:respond_to?).with(:'save_screenshot').and_return(false)
+      end
+
+      it 'saves driver render' do
+        expect(driver_mock).to receive(:render).with(screenshot_path)
+
+        saver.save
+        expect(saver).to be_screenshot_saved
+      end
+    end
+
+    context 'has save_screenshot method' do
+      let(:webkit_options){ {width: 800, height: 600} }
+
+      before do
+        allow(driver_mock).to receive(:respond_to?).with(:'save_screenshot').and_return(true)
+      end
+
+      it 'saves driver render' do
+        expect(driver_mock).to receive(:save_screenshot).with(screenshot_path, {})
+
+        saver.save
+        expect(saver).to be_screenshot_saved
+      end
+
+      it 'passes webkit_options to driver' do
+        allow(Capybara::Screenshot).to receive(:webkit_options).and_return( webkit_options )
+        expect(driver_mock).to receive(:save_screenshot).with(screenshot_path, webkit_options)
+
+        saver.save
+        expect(saver).to be_screenshot_saved
+      end
+    end
+  end
+
+  describe "with webkit debug driver" do
+    before do
+      allow(capybara_mock).to receive(:current_driver).and_return(:webkit_debug)
+    end
+
+    it 'saves driver render' do
+      expect(driver_mock).to receive(:render).with(screenshot_path)
+
+      saver.save
+      expect(saver).to be_screenshot_saved
+    end
+  end
+
+  describe "with unknown driver" do
+    before do
+      allow(capybara_mock).to receive(:current_driver).and_return(:unknown)
+      allow(saver).to receive(:warn).and_return(nil)
+    end
+
+    it 'saves driver render' do
+      expect(driver_mock).to receive(:render).with(screenshot_path)
+
+      saver.save
+      expect(saver).to be_screenshot_saved
+    end
+
+    it 'outputs warning about unknown results' do
+      # Not pure mock testing
+      expect(saver).to receive(:warn).with(/screenshot driver for 'unknown'.*unknown results/).and_return(nil)
+
+      saver.save
+      expect(saver).to be_screenshot_saved
+    end
+
+    describe "with rack_test driver" do
+      before do
+        allow(capybara_mock).to receive(:current_driver).and_return(:rack_test)
+      end
+
+      it 'indicates that a screenshot could not be saved' do
+        saver.save
+        expect(saver).to_not be_screenshot_saved
+      end
+    end
+
+    describe "with mechanize driver" do
+      before do
+        allow(capybara_mock).to receive(:current_driver).and_return(:mechanize)
+      end
+
+      it 'indicates that a screenshot could not be saved' do
+        saver.save
+        expect(saver).to_not be_screenshot_saved
+      end
+    end
+  end
+end