leifcr-capybara-screenshot 1.0.14

data/spec/unit/s3_saver_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'capybara-screenshot/s3_saver'
+
+describe Capybara::Screenshot::S3Saver do
+  let(:saver) { double('saver') }
+  let(:bucket_name) { double('bucket_name') }
+  let(:s3_client) { double('s3_client') }
+
+  let(:s3_saver) { Capybara::Screenshot::S3Saver.new(saver, s3_client, bucket_name) }
+
+  describe '.new_with_configuration' do
+    let(:access_key_id) { double('access_key_id') }
+    let(:secret_access_key) { double('secret_access_key') }
+    let(:s3_client_credentials_using_defaults) {
+      {
+        access_key_id: access_key_id,
+        secret_access_key: secret_access_key
+      }
+    }
+
+    let(:region) { double('region') }
+    let(:s3_client_credentials) {
+      s3_client_credentials_using_defaults.merge(region: region)
+    }
+
+    it 'destructures the configuration into its components' do
+      allow(Aws::S3::Client).to receive(:new).and_return(s3_client)
+      allow(Capybara::Screenshot::S3Saver).to receive(:new)
+
+      Capybara::Screenshot::S3Saver.new_with_configuration(saver, {
+        s3_client_credentials: s3_client_credentials,
+        bucket_name: bucket_name
+      })
+
+      expect(Aws::S3::Client).to have_received(:new).with(s3_client_credentials)
+      expect(Capybara::Screenshot::S3Saver).to have_received(:new).with(saver, s3_client, bucket_name)
+    end
+
+    it 'defaults the region to us-east-1' do
+      default_region = 'us-east-1'
+
+      allow(Aws::S3::Client).to receive(:new).and_return(s3_client)
+      allow(Capybara::Screenshot::S3Saver).to receive(:new)
+
+      Capybara::Screenshot::S3Saver.new_with_configuration(saver, {
+          s3_client_credentials: s3_client_credentials_using_defaults,
+          bucket_name: bucket_name
+      })
+
+      expect(Aws::S3::Client).to have_received(:new).with(
+        s3_client_credentials.merge(region: default_region)
+      )
+
+      expect(Capybara::Screenshot::S3Saver).to have_received(:new).with(saver, s3_client, bucket_name)
+    end
+  end
+
+  describe '#save' do
+    before do
+      allow(saver).to receive(:html_saved?).and_return(false)
+      allow(saver).to receive(:screenshot_saved?).and_return(false)
+      allow(saver).to receive(:save)
+    end
+
+    it 'calls save on the underlying saver' do
+      expect(saver).to receive(:save)
+
+      s3_saver.save
+    end
+
+    it 'uploads the html' do
+      html_path = '/foo/bar.html'
+      expect(saver).to receive(:html_path).and_return(html_path)
+      expect(saver).to receive(:html_saved?).and_return(true)
+
+      html_file = double('html_file')
+
+      expect(File).to receive(:open).with(html_path).and_yield(html_file)
+
+      expect(s3_client).to receive(:put_object).with(
+        bucket: bucket_name,
+        key: 'bar.html',
+        body: html_file
+      )
+
+      s3_saver.save
+    end
+
+    it 'uploads the screenshot' do
+      screenshot_path = '/baz/bim.jpg'
+      expect(saver).to receive(:screenshot_path).and_return(screenshot_path)
+      expect(saver).to receive(:screenshot_saved?).and_return(true)
+
+      screenshot_file = double('screenshot_file')
+
+      expect(File).to receive(:open).with(screenshot_path).and_yield(screenshot_file)
+
+      expect(s3_client).to receive(:put_object).with(
+        bucket: bucket_name,
+        key: 'bim.jpg',
+        body: screenshot_file
+      )
+
+      s3_saver.save
+    end
+  end
+
+  # Needed because we cannot depend on Verifying Doubles
+  # in older RSpec versions
+  describe 'an actual saver' do
+    it 'implements the methods needed by the s3 saver' do
+      instance_methods = Capybara::Screenshot::Saver.instance_methods
+
+      expect(instance_methods).to include(:save)
+      expect(instance_methods).to include(:html_saved?)
+      expect(instance_methods).to include(:html_path)
+      expect(instance_methods).to include(:screenshot_saved?)
+      expect(instance_methods).to include(:screenshot_path)
+    end
+  end
+
+  describe 'any other method' do
+    it 'transparently passes through to the saver' do
+      allow(saver).to receive(:foo_bar)
+
+      args = double('args')
+      s3_saver.foo_bar(*args)
+
+      expect(saver).to have_received(:foo_bar).with(*args)
+    end
+  end
+end

data/spec/unit/saver_spec.rb

@@ -0,0 +1,366 @@
+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.tap do |m|
+      allow(m).to receive(:current_path).and_return('/')
+    end
+  }
+  let(:capybara_mock) {
+    double(Capybara).as_null_object.tap do |m|
+      allow(m).to receive(:current_driver).and_return(:default)
+    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(page_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
+
+  context 'when saving a screenshot fails' do
+    it 'still restores the original value of Capybara.save_and_open_page_path' do
+      Capybara::Screenshot.capybara_tmp_path = 'tmp/bananas'
+
+      expect(capybara_mock).to receive(:save_page).and_raise
+
+      expect {
+        saver.save
+      }.to raise_error(RuntimeError)
+
+      if Capybara.respond_to?(:save_path)
+        expect(Capybara.save_path).to eq('tmp/bananas')
+      else
+        expect(Capybara.save_and_open_page_path).to eq('tmp/bananas')
+      end
+    end
+  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 'callbacks' 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
+
+    before :all do
+      Capybara::Screenshot.after_save_html do |path|
+        puts "after_save_html ran with #{path}"
+      end
+      Capybara::Screenshot.after_save_screenshot do |path|
+        puts "after_save_screenshot ran with #{path}"
+      end
+    end
+
+    after :all do
+      Capybara::Screenshot::Saver.instance_eval { @callbacks = nil }
+    end
+
+    it 'runs after_save_html callbacks' do
+      expect do
+        saver.save
+      end.to output(/after_save_html ran with page\.html/).to_stdout
+    end
+
+    it 'runs after_save_screenshot callbacks' do
+      expect do
+        saver.save
+      end.to output(/after_save_screenshot ran with screenshot\.png/).to_stdout
+    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
+
+    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 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