capybara-screenshot-nocolor 1.0.5

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,97 @@
+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::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.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  #{"HTML screenshot: 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  #{"HTML screenshot: path/to/html"}\n  #{"Image screenshot: 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  #{"HTML screenshot: 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

data/spec/unit/saver_spec.rb

@@ -0,0 +1,282 @@
+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 poltergeist_billy driver" do
+    before do
+      allow(capybara_mock).to receive(:current_driver).and_return(:poltergeist_billy)
+    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