cezanne 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3b042161b943e9c613765446eb96de02c932c1ed
+  data.tar.gz: ea2b8b6803ed4cb416da7dc9d031265f8ce368f4
+SHA512:
+  metadata.gz: f839e12234ddb4d54248264aa6d974191d129c705652eb01f98d860463e6a9e47d1f68e9bf77c981e7e41253aecd4546fceb3f86002d3fe6a290a8643a372b3f
+  data.tar.gz: 42f2832a17ce4a8cc10bed8ae5bedaca3c334ef953da157a8e30751e90597b26605a53cc2b9eb9ef3966290a0fef77533b01c2e8e7ef0d7e05fbbc4e2ee875e5

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+artifacts
+*.swp
+.DS_Store
+.env

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cezanne.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrea Pigato
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Cezanne
+
+Visual regression testing tool
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cezanne'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cezanne
+
+## Usage
+
+coming soon
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/cezanne/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/cezanne.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cezanne/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cezanne"
+  spec.version       = Cezanne::VERSION
+  spec.authors       = ["Sky Haiku"]
+  spec.email         = ["skyhaikuteam@gmail.com"]
+  spec.summary       = %q{Visual regression testing tool}
+  spec.description   = %q{Let Cezanne help you make sure your views look alright}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "capybara"
+  spec.add_development_dependency "selenium-webdriver"
+
+  spec.add_dependency "rmagick"
+  spec.add_dependency "dropscreen"
+end

data/lib/cezanne/comparison.rb

@@ -0,0 +1,14 @@
+require 'RMagick'
+
+module Cezanne
+
+  SIMILARITY_THRESHOLD = 42
+
+  def spot_differences_between this, that
+    width = [this.width, that.width].min
+    height = [this.height, that.height].min
+    [this, that].each { |img| img.crop!(width, height) }
+    this.picture.compare_channel(that.picture, Magick::PeakSignalToNoiseRatioMetric)[1] < SIMILARITY_THRESHOLD
+  end
+
+end

data/lib/cezanne/image.rb

@@ -0,0 +1,27 @@
+require 'RMagick'
+
+module Cezanne
+
+  class Image
+    attr_reader :path, :picture
+
+    def initialize path
+      @path = path
+      @picture = Magick::Image.read(@path).first
+    end
+
+    def crop! *coords
+      if coords.length == 2 then coords = [0, 0, *coords] end # treat them as widht and height
+      @picture.crop!(*coords)
+    end
+
+    def width
+      @picture.columns
+    end
+
+    def height
+      @picture.rows
+    end
+  end
+
+end

data/lib/cezanne/local_files.rb

@@ -0,0 +1,36 @@
+module Cezanne
+
+  class LocalFiles
+
+    def initialize uid, base_path
+
+      @folders = {
+        ref: File.join(base_path, 'reference_screenshots'),
+        diff: File.join(base_path, uid, 'different_screenshots'),
+        new: File.join(base_path, uid, 'new_screenshots'),
+        tmp: File.join(base_path, uid, 'tmp_screenshots')
+      }
+
+      @folders.each { |key, path| setup_directory_for key }
+
+    end
+
+    def path_for key
+      @folders[key]
+    end
+
+    def clean
+      path = File.dirname( path_for(:ref) )
+      FileUtils.rm_rf path
+    end
+
+    private
+
+      def setup_directory_for key
+        FileUtils.rm_rf path_for(key)
+        FileUtils.mkdir_p path_for(key)
+      end
+
+  end
+
+end

data/lib/cezanne/remote_files.rb

@@ -0,0 +1,27 @@
+require 'dropscreen'
+
+module Cezanne
+
+  class RemoteFiles
+
+    def initialize uid, base_path
+      @remote_folders = {
+        ref: File.join('reference_screenshots'),
+        diff: File.join(uid, 'different_screenshots'),
+        new: File.join(uid, 'new_screenshots')
+      }
+
+      @adapter = Dropscreen::Client.new( remote_base_dir: base_path, local_base_dir: './' )
+    end
+
+    def pull key, path
+      @adapter.pull @remote_folders[key], path
+    end
+
+    def push path, key
+      @adapter.push path, @remote_folders[key]
+    end
+
+  end
+
+end

data/lib/cezanne/rspec.rb

@@ -0,0 +1,43 @@
+require 'cezanne'
+require 'rspec/core'
+
+RSpec.configure do |config|
+
+  config.add_setting :cezanne
+
+  config.before(:all, screenshots: true) do
+    if self.class.include?(Cezanne)
+      uid = config.cezanne[:uid]
+      project_name = config.cezanne[:project_name]
+      config.cezanne[:local_files] = Cezanne::LocalFiles.new(uid, 'artifacts')
+      config.cezanne[:remote_files] = Cezanne::RemoteFiles.new(uid, project_name)
+      begin
+        config.cezanne[:remote_files].pull(:ref, config.cezanne[:local_files].path_for(:ref))
+      rescue 
+        puts "no reference screenshot exist for project #{project_name}"
+      end
+    end
+  end
+
+  config.after(:all, screenshots: true) do
+    if self.class.include?(Cezanne)
+      [:new, :diff].each do |key|
+        config.cezanne[:remote_files].push(config.cezanne[:local_files].path_for(key), key)
+      end
+      config.cezanne[:local_files].clean
+    end
+  end
+
+end
+
+module Cezanne
+
+  def local_files
+    RSpec.configuration.cezanne[:local_files]
+  end
+
+  def remote_files
+    RSpec.configuration.cezanne[:remote_files]
+  end
+
+end

data/lib/cezanne/version.rb

@@ -0,0 +1,3 @@
+module Cezanne
+  VERSION = "0.0.1"
+end

data/lib/cezanne.rb

@@ -0,0 +1,56 @@
+require "cezanne/version"
+require "cezanne/local_files"
+require "cezanne/remote_files"
+require "cezanne/image"
+require "cezanne/comparison"
+
+module Cezanne
+
+  def check_visual_regression_for page_name
+    screenshot = take_screenshot page_name
+    reference_screenshot = get_reference_screenshot_for page_name
+
+    unless reference_screenshot
+      mark_as_new screenshot
+      raise "new screenshot for #{page_name}"
+    end
+
+    if spot_differences_between screenshot, reference_screenshot
+      mark_for_review screenshot
+      raise "screenshot for #{page_name} didn't match"
+    end
+
+    return true
+  end
+
+  private 
+
+    def take_screenshot page_name
+      path = File.join( local_files.path_for(:tmp), file_name_for(page_name) )
+      page.driver.browser.save_screenshot(path)
+      image(path)
+    end
+
+
+    def get_reference_screenshot_for page_name
+      path = File.join( local_files.path_for(:ref), file_name_for(page_name) )
+      return false unless File.exists? path
+      image(path)
+    end
+
+    def file_name_for page_name
+      "#{page_name}_#{page.driver.browser.browser.to_s}.gif"
+    end
+
+    def mark_as_new screenshot
+      FileUtils.mv(screenshot.path, local_files.path_for(:new))
+    end
+
+    def mark_for_review screenshot
+      FileUtils.mv(screenshot.path, local_files.path_for(:diff))
+    end
+   
+    def image path 
+      Cezanne::Image.new(path)
+    end
+end

data/spec/cezanne_filesystem_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Cezanne::LocalFiles do 
+  
+  before(:each) do
+    @local_files = Cezanne::LocalFiles.new 'test', 'spec/artifacts' 
+  end
+  
+  describe '#initialize' do
+
+    it 'create local folders for the screenshots' do
+      expect(File.exists?('spec/artifacts/reference_screenshots')).to be true
+      expect(File.exists?('spec/artifacts/test/different_screenshots')).to be true
+      expect(File.exists?('spec/artifacts/test/new_screenshots')).to be true
+    end
+
+  end
+  
+  describe '#path_for' do
+
+    it 'is a path helper' do  
+      [:ref, :diff, :new, :tmp].each do |key|
+        expect(@local_files.path_for(key)).to eq(@local_files.instance_variable_get(:@folders)[key])
+      end
+    end
+
+  end
+
+  describe '#clean' do
+
+    it 'remove all local folders' do
+      @local_files.clean 
+      expect(File.exists?('spec/artifacts/local_files_test')).to be false
+    end
+
+  end
+  
+  after(:each) do
+    FileUtils.rm_rf 'spec/artifacts'
+  end
+
+end
+
+describe Cezanne::RemoteFiles do
+ 
+  let(:dropscreen_client) { double('Dropscreen::Client') }
+
+  before(:each) do 
+    allow(Dropscreen::Client).to receive('new').and_return(dropscreen_client)  
+    @remote_files = Cezanne::RemoteFiles.new 'test_uid', 'cezanne'
+  end
+
+  describe '#pull' do
+
+    it 'is a proxy to Dropscreen::Client#pull' do
+      expect(dropscreen_client).to receive(:pull).at_least(1).times.with(kind_of(String), 'local_path')  
+      [:ref, :diff, :new].each do |key|
+        @remote_files.pull key, 'local_path'
+      end 
+    end
+
+  end
+
+  describe '#push' do
+    
+    it 'is a proxy to Dropscreen::Client#push' do
+      expect(dropscreen_client).to receive(:push).at_least(1).times.with('local_path', kind_of(String))  
+      [:ref, :diff, :new].each do |key|
+        @remote_files.push 'local_path', key 
+      end
+    end 
+  end
+  
+end
+

data/spec/cezanne_image_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Cezanne::Image do
+
+  let(:image) { Cezanne::Image.new('spec/images/page_name_browser.gif') }
+
+  describe '#initialize' do 
+    
+    it 'wraps Magick::Image' do
+      expect(image.picture).to be_instance_of(Magick::Image)    
+    end
+
+    it 'return an error if there is no file at path' do
+      expect { Cezanne::Image.new('unexistent_file_path') }.to raise_error
+    end
+  end
+  
+  describe '#width' do
+
+    it 'has a width' do
+      expect(image.width).to be 763
+    end
+
+  end
+
+  describe '#height' do
+
+    it 'has a height' do
+      expect(image.height).to be 599
+    end
+
+  end
+  
+  describe '#crop!' do
+
+    it 'accepts 4 parameters x, y, width, height' do
+      x = 1
+      y = 2
+      width = 5
+      height = 10
+      image.crop!(x,y,width,height)
+      expect(image.width).to be 5 
+      expect(image.height).to be 10   
+    end
+ 
+    it 'accepts width and height alone' do
+      width = 10
+      height = 5
+      image.crop!(width, height)
+      expect(image.width).to be 10
+      expect(image.height).to be 5
+    end
+
+  end
+end

data/spec/cezanne_rspec_spec.rb

@@ -0,0 +1,100 @@
+require 'cezanne/rspec'
+require 'capybara/rspec'
+require 'selenium-webdriver'
+require 'pry'
+
+
+Capybara.app = Rack::Directory.new('spec/images')
+Capybara.default_driver = :selenium
+
+RSpec.configure do |config|
+  config.include Cezanne
+  config.cezanne = { uid: 'test', project_name: 'cezanne' }
+end
+
+describe 'Cezanne RSpec integration', type: :feature, screenshots: true do
+ 
+  # wrap each test with before(:all) and after(:all) 
+
+  after(:all) do |example|
+    RSpec.configuration.after(:all, screenshots: true).last.instance_variable_set(:@block, Proc.new {}) # disable the after(:all) hook  
+  end
+
+  before(:each) do |example|
+    RSpec.configuration.before(:all, screenshots: true).first.run(example) 
+  end
+
+  after(:each) do |example|
+    RSpec.configuration.after(:all, screenshots: true).last.run(example) unless example.metadata[:after_hook_test] 
+  end
+
+
+
+
+
+
+  describe 'initialization' do
+   
+    it 'create local folders' do 
+      expect(File.exist?('artifacts/reference_screenshots')).to be true
+      expect(File.exist?('artifacts/test/tmp_screenshots')).to be true 
+      expect(File.exist?('artifacts/test/different_screenshots')).to be true 
+      expect(File.exist?('artifacts/test/new_screenshots')).to be true 
+    end
+ 
+
+    it 'pull reference_screenshots' do 
+      expect(File.exist?('artifacts/reference_screenshots/similar_firefox.gif')).to be true
+      expect(File.exist?('artifacts/reference_screenshots/different_firefox.gif')).to be true
+    end
+ 
+  end 
+  
+  describe 'take screenshots' do 
+
+    context 'similar' do
+
+      it 'pass the test' do
+        visit '/similar.html'
+        expect { check_visual_regression_for 'similar' }.not_to raise_error
+      end
+
+    end
+    
+    context 'different' do
+
+      it 'fail the test' do
+        visit '/different.html'
+        expect { check_visual_regression_for 'different' }.to raise_error
+      end
+
+    end
+
+    
+    context 'new' do
+
+      it 'fail the test' do
+        visit '/new.html'
+        expect { check_visual_regression_for 'new' }.to raise_error
+      end
+
+    end
+  
+  end
+
+  describe 'finalization', after_hook_test: true do
+    
+    it 'push new, diff screenshots to remote' do |example|
+      expect(RSpec.configuration.cezanne[:remote_files]).to receive('push').with(kind_of(String), :diff).and_call_original
+      expect(RSpec.configuration.cezanne[:remote_files]).to receive('push').with(kind_of(String), :new).and_call_original
+      RSpec.configuration.after(:all, screenshots: true).last.run(example)  
+    end
+
+    it 'clean local folders' do |example|
+      RSpec.configuration.after(:all, screenshots: true).last.run(example)
+      expect(File.exists?('artifacts')).to be false
+    end
+
+  end
+
+end

data/spec/cezanne_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Cezanne do
+
+  let(:class_with_cezanne) { Class.include(Cezanne).new }
+  # Capybara mocks
+  let(:page) { double('page') }
+  let(:driver) { double('driver') }
+  let(:browser) { double('browser') }
+  # RMagick mocks
+  let(:picture) { double('Magick::Image') }
+  # Cezanne classes mocks
+  let(:local_files) { double('local_files') }
+  let(:image) { double('Cezanne::Image') }
+
+  before(:each) do
+    allow(browser).to receive('browser').and_return(:browser)
+    allow(browser).to receive('save_screenshot')
+    allow(driver).to receive('browser').and_return(browser)
+    allow(page).to receive('driver').and_return(driver)
+    allow(local_files).to receive('path_for').and_return('spec/images')
+    allow(class_with_cezanne).to receive('page').and_return(page)
+    allow(class_with_cezanne).to receive('local_files').and_return(local_files) 
+    allow(class_with_cezanne).to receive('image').and_return(image)
+  end
+
+  describe '#take_screenshot' do
+
+    it 'take a screenshot using the browser driver' do
+      expect(page.driver.browser).to receive('save_screenshot')   
+      class_with_cezanne.send(:take_screenshot, 'page_name')
+    end
+    
+    it 'return a Cezanne::Image' do
+      expect(class_with_cezanne.send(:take_screenshot, 'page_name')).to be image
+    end
+    
+  end
+  
+  describe '#get_reference_screenshot_for' do 
+
+    it 'return the reference Cezanne::Image' do
+      expect(class_with_cezanne.send(:get_reference_screenshot_for, 'page_name')).to be image
+    end
+
+    it 'return false if the reference image does not exist' do 
+      expect(class_with_cezanne.send(:get_reference_screenshot_for, 'page_name_with_no_reference')).to be false
+    end
+
+  end
+
+  describe '#spot_differences_between' do 
+    
+    let(:this) { image }
+    let(:that) { this.clone }
+
+    before(:each) do
+      allow(image).to receive('picture').and_return(picture)
+      allow(image).to receive('crop!')
+      allow(picture).to receive('compare_channel').with(picture, Magick::PeakSignalToNoiseRatioMetric).and_return([nil, 1]) 
+      allow(this).to receive('width').and_return(1)
+      allow(this).to receive('height').and_return(2)
+      allow(that).to receive('width').and_return(2)
+      allow(that).to receive('height').and_return(1)
+    end
+
+    it 'crop images to min width and height' do 
+      expect(this).to receive('crop!').with(1,1)
+      expect(that).to receive('crop!').with(1,1)
+      class_with_cezanne.send(:spot_differences_between, this, that)
+    end
+  
+    context 'similar images' do
+      
+      it 'return false' do
+        expect(this.picture).to receive('compare_channel').and_return([nil, Cezanne::SIMILARITY_THRESHOLD + 1]) 
+        expect(class_with_cezanne.send(:spot_differences_between, this, that)).to be false 
+      end
+    
+    end
+    
+    context 'different images' do
+      
+      it 'return true' do
+        expect(this.picture).to receive('compare_channel').and_return([nil, Cezanne::SIMILARITY_THRESHOLD - 1]) 
+        expect(class_with_cezanne.send(:spot_differences_between, this, that)).to be true 
+      end
+    
+    end
+  end
+
+  describe '#file_name_for' do
+
+    it 'contains page_name and browser' do
+      expect(class_with_cezanne.send(:file_name_for, 'fancy_page_name')).to eq('fancy_page_name_browser.gif')
+    end
+  
+  end
+
+  describe '#mark_for_review' do
+    
+    let(:screenshot) { image }
+
+    before(:each) do
+      allow(image).to receive('path').and_return('spec/images/page_name_browser.gif')    
+    end 
+
+    it 'moves screenshot to the diff folder' do
+      expect(local_files).to receive('path_for').with(:diff).and_return('spec/images/different.gif')
+      class_with_cezanne.send(:mark_for_review, screenshot)
+      expect(File.exists?('spec/images/different.gif')).to be true
+    end
+
+    after(:each) do
+      FileUtils.mv('spec/images/different.gif', 'spec/images/page_name_browser.gif')
+    end
+
+  end
+
+
+  describe '#mark_as_new' do
+    
+    let(:screenshot) { image }
+
+    before(:each) do
+      allow(image).to receive('path').and_return('spec/images/page_name_browser.gif')    
+    end 
+
+    it 'moves screenshot to the new folder' do
+      expect(local_files).to receive('path_for').with(:new).and_return('spec/images/new.gif')
+      class_with_cezanne.send(:mark_as_new, screenshot)
+      expect(File.exists?('spec/images/new.gif')).to be true
+    end
+
+    after(:each) do
+      FileUtils.mv('spec/images/new.gif', 'spec/images/page_name_browser.gif')
+    end
+
+  end
+
+  describe '#image' do
+    
+    before(:each) do
+      allow(class_with_cezanne).to receive('image').and_call_original      
+    end
+
+    it 'return a Cezanne::Image' do
+      path = 'spec/images/page_name_browser.gif'
+      expect(class_with_cezanne.send(:image, path)).to be_instance_of(Cezanne::Image)
+    end
+    
+  end
+
+  describe '#check_visual_regression_for' do
+
+    before(:each) do
+      allow(class_with_cezanne).to receive('get_reference_screenshot_for').and_return(Cezanne::Image.new('spec/images/page_name_browser.gif'))
+    end
+
+    context 'succesful match' do
+
+      it 'does not raise an error' do
+        allow(class_with_cezanne).to receive('take_screenshot').and_return(Cezanne::Image.new('spec/images/page_name_browser.gif'))
+        expect { class_with_cezanne.check_visual_regression_for 'page_name' }.not_to raise_error
+      end
+
+    end
+
+    context 'failed match' do
+
+      let(:screenshot) { Cezanne::Image.new('spec/images/page_name_2_browser.gif') }
+
+      before(:each) do
+        allow(class_with_cezanne).to receive('take_screenshot').and_return(screenshot)
+        allow(class_with_cezanne).to receive('mark_for_review')
+      end
+
+      it 'raise a <did not match> error' do
+        expect { class_with_cezanne.check_visual_regression_for('page_name') }.to raise_error(/didn't match/)
+      end
+
+      it 'mark the screenshot for review' do
+        expect(class_with_cezanne).to receive('mark_for_review').with(screenshot)
+        begin 
+          class_with_cezanne.check_visual_regression_for('page_name') 
+        rescue 
+        end
+      end
+    end 
+
+    context 'new screenshot' do 
+
+      let(:screenshot) { Cezanne::Image.new('spec/images/page_name_browser.gif') }
+
+      before(:each) do
+        allow(class_with_cezanne).to receive('get_reference_screenshot_for').and_return(false)
+        allow(class_with_cezanne).to receive('take_screenshot').and_return(screenshot)
+        allow(class_with_cezanne).to receive('mark_as_new')
+      end
+
+      it 'raise a <new> error' do
+        expect { class_with_cezanne.check_visual_regression_for('page_name') }.to raise_error(/new screenshot/)
+      end
+      
+      it 'mark the screenshot as new' do
+        expect(class_with_cezanne).to receive('mark_as_new').with(screenshot) 
+        begin
+          class_with_cezanne.check_visual_regression_for('page_name')
+        rescue
+        end
+      end
+
+    end
+  end
+end

data/spec/images/different.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>DIFFERENT</title>
+  </head>
+  <body>
+    <img src="page_name_browser.gif" />
+  </body>
+</html>

data/spec/images/new.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>NEW</title>
+  </head>
+  <body>
+    <img src="page_name_2_browser.gif" />
+  </body>
+</html>

data/spec/images/similar.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>SIMILAR</title>
+  </head>
+  <body>
+    <img src="page_name_browser.gif" />
+  </body>
+</html>

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'cezanne'
+
+RSpec.configure do |config|
+end
+
+

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: cezanne
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sky Haiku
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dropscreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Let Cezanne help you make sure your views look alright
+email:
+- skyhaikuteam@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cezanne.gemspec
+- lib/cezanne.rb
+- lib/cezanne/comparison.rb
+- lib/cezanne/image.rb
+- lib/cezanne/local_files.rb
+- lib/cezanne/remote_files.rb
+- lib/cezanne/rspec.rb
+- lib/cezanne/version.rb
+- spec/cezanne_filesystem_spec.rb
+- spec/cezanne_image_spec.rb
+- spec/cezanne_rspec_spec.rb
+- spec/cezanne_spec.rb
+- spec/images/different.html
+- spec/images/new.html
+- spec/images/page_name_2_browser.gif
+- spec/images/page_name_browser.gif
+- spec/images/similar.html
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Visual regression testing tool
+test_files:
+- spec/cezanne_filesystem_spec.rb
+- spec/cezanne_image_spec.rb
+- spec/cezanne_rspec_spec.rb
+- spec/cezanne_spec.rb
+- spec/images/different.html
+- spec/images/new.html
+- spec/images/page_name_2_browser.gif
+- spec/images/page_name_browser.gif
+- spec/images/similar.html
+- spec/spec_helper.rb