gatling 1.0.7 → 1.0.8

data/lib/gatling/image_wrangler.rb

@@ -1,8 +1,7 @@
 module Gatling
-  class ImageWrangler
+  module ImageWrangler
 
     def self.get_element_position element
-
       element = element.native
       position = Hash.new{}
       position[:x] = element.location.x
@@ -17,8 +16,7 @@ module Gatling
       @cropped_element = image.crop(position[:x], position[:y], position[:width], position[:height])
     end
 
-    def self.exclude image, element_to_exclude
-    end
+
 
 
   end

data/lib/gatling/version.rb

@@ -1,3 +1,3 @@
 module Gatling
-  VERSION = "1.0.7"
+  VERSION = "1.0.8"
 end

data/spec/acceptance/gatling_acceptance_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+include Capybara::DSL
+
+describe 'Gatling' do
+
+  before(:all) do
+    @spec_support_root = spec_support_root
+  end
+
+  before(:each) do
+    @ref_path = Gatling::Configuration.reference_image_path = File.join(spec_support_root, 'ref_path')
+  end
+
+  after(:each) do
+    remove_refs(@ref_path)
+    Gatling::Configuration.trainer_toggle = false
+  end
+
+  describe 'Gatling, when no reference image exists' do
+
+    it "will notify that no reference image exists and create a candidate image" do
+      black_element = element_for_spec
+      expected_error = "The design reference #{"black.png"} does not exist, #{@ref_path}/candidate/#{"black.png"} " +
+                       "is now available to be used as a reference. " +
+                       "Copy candidate to root reference_image_path to use as reference"
+
+      expect {Gatling.matches?("black.png", black_element)}.should raise_error(RuntimeError, expected_error)
+
+      File.exists?(File.join(@ref_path, 'candidate', "black.png")).should be_true
+    end
+  end
+
+  describe 'Gatling image comparison' do
+
+    before(:each) do
+      create_square_image(@ref_path, 'black')
+    end
+
+    it 'will return true if the images are identical' do
+      black_element = element_for_spec('#black')
+
+      Gatling.matches?("black.png", black_element).should be_true
+    end
+
+    it 'will return false, creates new diff and candidate images if the images are different' do
+      red_element = element_for_spec('#red')
+      expected_error = "element did not match #{"black.png"}. " +
+                       "A diff image: #{"black.png"} was created in #{@ref_path}/diff/#{"black.png"}. " +
+                       "A new reference #{@ref_path}/candidate/#{"black.png"} can be used to fix the test"
+
+      expect {Gatling.matches?("black.png", red_element)}.should raise_error(RuntimeError, expected_error)
+
+      File.exists?(File.join(@ref_path,'diff', "black.png")).should be_true
+      File.exists?(File.join(@ref_path,'candidate', "black.png")).should be_true
+    end
+
+    # it 'will try to match a specified amount of time before failing' do
+    #      red_element = element_for_spec('#red')
+    #      Gatling.should_receive(:matches?).and_return(false)
+    #      Gatling.should_receive(:try_until_match)
+    #      Gatling.matches?("black.png", red_element)
+    #    end
+
+  end
+
+  describe 'Gatling trainer toggle' do
+
+    it 'will save a reference file if no reference file already exists' do
+      Gatling::Configuration.trainer_toggle = true
+      File.exists?(File.join(@ref_path, "black.png")).should be_false
+      $stdout.should_receive(:puts).with "Saved #{@ref_path}/#{"black.png"} as reference"
+      black_element = element_for_spec
+
+      expect {Gatling.matches?("black.png", black_element)}.should_not raise_error
+
+      File.exists?(File.join(@ref_path, "black.png")).should be_true
+    end
+
+    it 'will warn if a reference already exists and not overwrite it' do
+      create_square_image(@ref_path, 'black')
+      Gatling::Configuration.trainer_toggle = true
+      expected_message = " already exists. reference image was not overwritten. " +
+                         "please delete the old file to update using trainer"
+      black_element = element_for_spec
+      reference_file_ctime = File.ctime(File.join(@ref_path,"black.png"))
+
+      $stdout.should_receive(:puts).with expected_message
+      expect {Gatling.matches?("black.png", black_element)}.should_not raise_error
+
+      sleep(1)
+      reference_file_ctime.eql?(File.ctime(File.join(@ref_path, "black.png"))).should be_true
+    end
+  end
+end

data/spec/acceptance/rspec_matcher_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+include Capybara::DSL
+
+describe 'rspec matcher' do
+
+  before(:all) do
+    @black_box = 'black.png'
+    @ref_path = Gatling::Configuration.reference_image_path = File.join(spec_support_root, 'ref_path')
+    create_images_for_web_page
+  end
+
+  after(:each) do
+    Gatling::Configuration.trainer_toggle = false
+    remove_refs(@ref_path)
+  end
+
+  describe 'initializing and runnin gatling' do
+
+    it 'will pass if images matches reference' do
+      create_square_image(@ref_path, 'black')
+      black_element = element_for_spec("#black")
+      black_element.should look_like("black.png")
+    end
+
+    it 'will fail if images dosent matches reference' do
+      create_square_image(@ref_path, 'black')
+      red_element = element_for_spec("#red")
+      expect{red_element.should look_like(@black_box)}.should raise_error
+    end
+
+    it 'will return true if it makes a new reference image in trainer mode' do
+      Gatling::Configuration.trainer_toggle =  true
+      black_element = element_for_spec("#black")
+      black_element.should look_like(@black_box)
+      File.exists?(File.join(@ref_path, @black_box)).should be_true
+    end
+
+  end
+end

data/spec/comparison_spec.rb

@@ -5,27 +5,28 @@ describe Gatling::Comparison do
   before do
     apple = Magick::Image.new(100,100) { self.background_color = "green" }
     orange = Magick::Image.new(100,100) { self.background_color = "orange" }
-    @apple = Gatling::Image.new(:from_diff, 'apple.png', apple)
-    @orange = Gatling::Image.new(:from_diff, 'orange.png', orange)
+    @apple = Gatling::Image.new(apple, "apple.png")
+    @orange = Gatling::Image.new(orange, "orange.png")
+  end
+
+  describe 'will make images from ' do
+
   end
 
   describe 'will compare two images' do
 
     it 'will return true if the images are identical' do
-      subject = Gatling::Comparison.new(@apple, @apple)
-      subject.match.should == true
+      Gatling::Comparison.new(@apple, @apple).matches?.should == true
     end
 
     it 'will return false if the images are different' do
-      subject = Gatling::Comparison.new(@apple, @orange)
-      subject.match.should == false
+      Gatling::Comparison.new(@orange, @apple).matches?.should == false
     end
   end
 
   describe 'Diff images' do
     it 'will give us a diff' do
-      subject = Gatling::Comparison.new(@apple, @orange)
-      subject.diff_image.class.should == Gatling::Image
+      Gatling::Comparison.new(@apple, @orange).diff_image.class.should == Gatling::Image
     end
   end
 end

data/spec/configuration_spec.rb

@@ -2,15 +2,18 @@ require 'spec_helper'
 
 describe Gatling::Configuration do
 
-  describe "#reference_image_path" do
-    before :each do
+  after :each do
       Gatling::Configuration.reference_image_path = nil
-    end 
+      Gatling.reference_image_path = nil
+  end
+
+  describe "#reference_image_path" do
+
 
     describe "Without Rails" do
       it "should default to './spec/reference_images' when not in a rails environment" do
         Gatling::Configuration.reference_image_path.should eql("spec/reference_images")
-      end    
+      end
     end
 
     describe "with rails" do
@@ -38,32 +41,32 @@ describe Gatling::Configuration do
       end
 
     end
-  end  
+  end
 
   describe '#trainer_toggle' do
 
     it 'should default to false' do
-      Gatling::Configuration.trainer_toggle.should eql(false)
+      subject.trainer_toggle.should eql(false)
     end
 
     it 'can be toggled to true' do
       Gatling::Configuration.trainer_toggle = true
-      Gatling::Configuration.trainer_toggle.should eql(true)
+      subject.trainer_toggle.should eql(true)
     end
 
     it 'toggeled using GATLING_TRAINER = false' do
       ENV['GATLING_TRAINER'] = 'false'
-      Gatling::Configuration.trainer_toggle.should eql(false)
+      subject.trainer_toggle.should eql(false)
     end
 
     it 'toggeled using GATLING_TRAINER = true' do
       ENV['GATLING_TRAINER'] = 'true'
-      Gatling::Configuration.trainer_toggle.should eql(true)
+      subject.trainer_toggle.should eql(true)
     end
 
     it 'toggeled using GATLING_TRAINER = nil' do
       ENV['GATLING_TRAINER'] = nil
-      Gatling::Configuration.trainer_toggle.should eql(false)
+      subject.trainer_toggle.should eql(false)
     end
 
     after(:each) do
@@ -75,12 +78,51 @@ describe Gatling::Configuration do
   describe 'paths' do
     it 'should return the directory for a type of image' do
       Gatling::Configuration.reference_image_path = "a_path"
-      Gatling::Configuration.path_from_type(:temp).should == 'a_path/temp' 
+      subject.path(:temp).should == 'a_path/temp'
     end
 
     it 'should thrown an error when you ask for the path of an unknown image type' do
-      expect { Gatling::Configuration.path_from_type(:unknown)}.should raise_error "Unkown image type 'unknown'"
+      expect { Gatling::Configuration.path(:unknown)}.should raise_error "Unkown image type 'unknown'"
+    end
+  end
+
+  describe "#max_no_tries" do
+
+      it "should default to 5" do
+        subject.max_no_tries.should == 5
+      end
+
+      it "should be settable" do
+        Gatling::Configuration.max_no_tries = 1
+        subject.max_no_tries.should == 1
+      end
+  end
+
+  describe "#sleep_between_tries" do
+
+    it "should default to 0.5" do
+      subject.sleep_between_tries.should == 0.5
     end
-  end  
+
+    it "should be settable" do
+      Gatling::Configuration.sleep_between_tries = 55
+      subject.sleep_between_tries.should eql 55
+    end
+  end
+
+  describe "settings" do
+
+    it "should accept a block of settings and parse them correctly" do
+      Gatling.config do |setting|
+        Gatling.reference_image_path = 'custom_path'
+        Gatling.max_no_tries = 3
+        Gatling.sleep_between_tries = 0.7
+      end
+      subject.reference_image_path.should eql 'custom_path'
+      subject.max_no_tries.should eql 3
+      subject.sleep_between_tries.should eql 0.7
+    end
+
+  end
 
 end

data/spec/gatling_spec.rb

@@ -1,89 +1,94 @@
 require 'spec_helper'
 include Capybara::DSL
 
-describe 'Gatling' do
+describe Gatling do
 
-  before(:all) do
+  before :all do
     @spec_support_root = spec_support_root
+    @box = 'box'
     @black_box = 'black.png'
     @red_box = 'red.png'
-    create_images_for_web_page
+    @ref_path = Gatling::Configuration.reference_image_path = './ref_path'
   end
 
-  before(:each) do
-    @ref_path = Gatling::Configuration.reference_image_path = File.join(spec_support_root, 'ref_path')
-  end
-
-  after(:each) do
-    remove_refs(@ref_path)
+  after :each  do
     Gatling::Configuration.trainer_toggle = false
   end
 
-  describe 'Gatling, when no reference image exists' do
-
-    it "will notify that no reference image exists and create a candidate image" do
-      black_element = element_for_spec
-      expected_error = "The design reference #{@black_box} does not exist, #{@ref_path}/candidate/#{@black_box} " +
-                       "is now available to be used as a reference. " +
-                       "Copy candidate to root reference_image_path to use as reference"
-
-      expect {Gatling.matches?(@black_box, black_element)}.should raise_error(RuntimeError, expected_error)
+  describe '#Gatling' do
 
-      File.exists?(File.join(@ref_path, 'candidate', @black_box)).should be_true
-    end
-  end
-
-  describe 'Gatling image comparison' do
-
-    before(:each) do
-      create_square_image(@ref_path, 'black')
+    before :each do
+      @image_class_mock = mock(Gatling::Image)
     end
 
     it 'will return true if the images are identical' do
-      black_element = element_for_spec('#black')
-
-      Gatling.matches?(@black_box, black_element).should be_true
+        @apple = mock("Gatling::Image")
+        @orange = mock("Gatling::Image")
+        @element  = mock("Gatling::CaptureElement")
+        @comparison = mock("Gatling::Comparison")
+        Gatling::ImageFromFile.stub!(:new).and_return(@orange)
+        Gatling::ImageFromElement.stub!(:new).and_return(@orange)
+        Gatling::Comparison.stub!(:new).and_return(@comparison)
+        @comparison.stub!(:matches?).and_return(true)
+        File.stub!(:exists?).and_return(true)
+        subject.matches?("orange.png", @element).should be_true
     end
 
-    it 'will return false, creates new diff and candidate images if the images are different' do
-      red_element = element_for_spec('#red')
-      expected_error = "element did not match #{@black_box}. " +
-                       "A diff image: #{@black_box} was created in #{@ref_path}/diff/#{@black_box}. " +
-                       "A new reference #{@ref_path}/candidate/#{@black_box} can be used to fix the test"
-
-      expect {Gatling.matches?(@black_box, red_element)}.should raise_error(RuntimeError, expected_error)
+    it "#save_image_as_diff" do
+      @image_class_mock.should_receive(:save).with(:as => :diff).and_return(@ref_path)
+      @image_class_mock.should_receive(:file_name).at_least(:once).and_return("some_name")
+      expect {subject.save_image_as_diff(@image_class_mock)}.should raise_error
+    end
 
-      File.exists?(File.join(@ref_path,'diff', @black_box)).should be_true
-      File.exists?(File.join(@ref_path,'candidate', @black_box)).should be_true
+    it "#save_image_as_candidate" do
+      @image_class_mock.should_receive(:save).with(:as => :candidate).and_return(@ref_path)
+      @image_class_mock.should_receive(:file_name).at_least(:once).and_return("some_name")
+      @image_class_mock.should_receive(:path).and_return(@path)
+      expect {subject.save_image_as_candidate(@image_class_mock)}.should raise_error
     end
-  end
 
-  describe 'Gatling trainer toggle' do
+    describe "#save_image_as_reference" do
 
-    it 'will save a reference file if no reference file already exists' do
-      Gatling::Configuration.trainer_toggle = true
-      File.exists?(File.join(@ref_path, @black_box)).should be_false
-      $stdout.should_receive(:puts).with "Saved #{@ref_path}/#{@black_box} as reference"
-      black_element = element_for_spec
+      it "when image.exists? == true" do
+        @image_class_mock.should_receive(:exists?).and_return(true)
+        @image_class_mock.should_receive(:path).and_return(@path)
+        @image_class_mock.should_not_receive(:save)
+        subject.save_image_as_reference(@image_class_mock)
+      end
 
-      expect {Gatling.matches?(@black_box, black_element)}.should_not raise_error
+      it "when image_exists? == false" do
+        @image_class_mock.should_receive(:exists?).and_return(false)
+        @image_class_mock.should_receive(:save).with(:as => :reference).and_return(@ref_path)
+        @image_class_mock.should_receive(:path).and_return(@path)
+        subject.save_image_as_reference(@image_class_mock)
+      end
 
-      File.exists?(File.join(@ref_path, @black_box)).should be_true
     end
 
-    it 'will warn if a reference already exists and not overwrite it' do
-      create_square_image(@ref_path, 'black')
-      Gatling::Configuration.trainer_toggle = true
-      expected_message = " already exists. reference image was not overwritten. " +
-                         "please delete the old file to update using trainer"
-      black_element = element_for_spec
-      reference_file_ctime = File.ctime(File.join(@ref_path,@black_box))
 
-      $stdout.should_receive(:puts).with expected_message
-      expect {Gatling.matches?(@black_box, black_element)}.should_not raise_error
 
-      sleep(1)
-      reference_file_ctime.eql?(File.ctime(File.join(@ref_path, @black_box))).should be_true
     end
+
+describe "#compare_until_match" do
+
+      before do
+        @apple = mock("Gatling::Image")
+        @orange = mock("Gatling::Image")
+        @element  = mock(Gatling::CaptureElement)
+        @comparison = mock("Gatling::Comparison")
+        Gatling::ImageFromFile.stub!(:new).and_return(@orange)
+        Gatling::ImageFromElement.stub!(:new).and_return(@orange)
+        Gatling::Comparison.stub!(:new).and_return(@comparison)
+      end
+
+      it "should try match for a specified amount of times" do
+        @comparison.should_receive(:matches?).exactly(3).times
+        Gatling.compare_until_match(@element, "orange.png", 3)
+      end
+
+      it "should pass after a few tries if match is found" do
+        @comparison.should_receive(:matches?).exactly(1).times.and_return(true)
+        Gatling.compare_until_match(@element, "orange.png", 3)
+      end
   end
-end
+end