eyes_selenium 1.6.0

data/lib/eyes_selenium/eyes/session.rb

@@ -0,0 +1,14 @@
+class Applitools::Session
+  attr_reader :eyes, :id, :url
+  attr_accessor :new_session
+  def initialize(session_id, session_url, new_session)
+    @new_session = new_session
+    @id = session_id
+    @url = session_url
+  end
+
+  def new_session?
+    self.new_session
+  end
+end
+

data/lib/eyes_selenium/eyes/start_info.rb

@@ -0,0 +1,34 @@
+class Applitools::StartInfo
+
+  ATTRIBUTES = %w[ agent_id app_id_or_name ver_id scenario_id_or_name batch_info
+                environment application match_level branch_name parent_branch_name ]
+
+  ATTRIBUTES.each do |attr|
+    attr_accessor attr
+  end
+
+  ## add a config file with this stuff, and use hash arg
+  def initialize(agent_id, app_id_or_name, scenario_id_or_name, batch_info, environment,
+                 application, match_level, ver_id=nil, branch_name=nil, 
+                 parent_branch_name=nil)
+    @agent_id = agent_id
+    @app_id_or_name = app_id_or_name
+    @ver_id = ver_id
+    @scenario_id_or_name = scenario_id_or_name
+    @batch_info = batch_info
+    @environment = environment
+    @application = application
+    @match_level = match_level
+    @branch_name = branch_name
+    @parent_branch_name = parent_branch_name
+  end
+
+  def to_hash
+    {  
+      AgentId: agent_id, AppIdOrName: app_id_or_name, VerId: ver_id, ScenarioIdOrName: scenario_id_or_name,
+      BatchInfo: batch_info.to_hash, Environment: environment.to_hash, 
+      Application: application.to_hash, matchLevel: match_level, branchName: branch_name,
+      parentBranchName: parent_branch_name
+    }
+  end
+end

data/lib/eyes_selenium/eyes/target_app.rb

@@ -0,0 +1,17 @@
+class Applitools::TargetApp
+
+  attr_reader :url, :session_id, :user_agent
+
+  def initialize(url, session_id, user_agent)
+    @url = url
+    @session_id = session_id
+    @user_agent = user_agent
+  end
+
+  def to_hash
+    {
+      "$type" => "Applitools.Framework.TargetWebDriverApplication, Core", 
+      url: URI.encode(url.to_s), sessionId: session_id, userAgent: user_agent
+    }
+  end
+end

data/lib/eyes_selenium/eyes/test_results.rb

@@ -0,0 +1,21 @@
+class Applitools::TestResults
+  attr_reader :steps, :matches, :mismatches, :missing, :exact_matches, :strict_matches,
+              :context_matches, :layout_matches, :none_matches
+  def initialize(steps=0, matches=0, mismatches=0, missing=0,
+                 exact_matches=0, strict_matches=0, content_matches=0, 
+                 layout_matches=0, none_matches=0)
+    @steps = steps
+    @matches = matches
+    @mismatches =  mismatches
+    @missing =  missing
+    @exact_matches =  exact_matches
+    @strict_matches = strict_matches
+    @content_matches =  content_matches
+    @layout_matches =  layout_matches
+    @none_matches =  none_matches
+  end
+
+  def to_s
+    "[ steps: #{steps}, matches: #{matches}, mismatches: #{mismatches}, missing: #{missing} ]"
+  end
+end

data/lib/eyes_selenium/eyes/text_trigger.rb

@@ -0,0 +1,15 @@
+class Applitools::TextTrigger
+  
+  attr_reader :text, :control
+
+  def initialize(text, control)
+    @text = text
+    @control = control
+  end
+
+  def to_hash
+    {
+      "$type" => "Applitools.Models.TextTrigger, Core", text: text, control: control.to_hash
+    }
+  end
+end

data/lib/eyes_selenium/eyes/viewport_size.rb

@@ -0,0 +1,104 @@
+class Applitools::ViewportSize
+
+  GET_VIEWPORT_HEIGHT_JAVASCRIPT_FOR_NORMAL_BROWSER = "return window.innerHeight"
+  GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_NORMAL_BROWSER  = "return window.innerWidth"
+
+  DOCUMENT_CLEAR_SCROLL_BARS_JAVASCRIPT = "var doc = document.documentElement;" +
+                                          "var previousOverflow = doc.style.overflow;"
+  DOCUMENT_RESET_SCROLL_BARS_JAVASCRIPT = "doc.style.overflow = previousOverflow;"
+  DOCUMENT_RETURN_JAVASCRIPT            = "return __applitools_result;"
+
+  GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_BAD_BROWSERS = 
+                  DOCUMENT_CLEAR_SCROLL_BARS_JAVASCRIPT        +
+                  "var __applitools_result = doc.clientWidth;" +
+                  DOCUMENT_RESET_SCROLL_BARS_JAVASCRIPT        +
+                  DOCUMENT_RETURN_JAVASCRIPT
+
+  GET_VIEWPORT_HEIGHT_JAVASCRIPT_FOR_BAD_BROWSERS = 
+                  DOCUMENT_CLEAR_SCROLL_BARS_JAVASCRIPT         +
+                  "var __applitools_result = doc.clientHeight;" +
+                  DOCUMENT_RESET_SCROLL_BARS_JAVASCRIPT         +
+                  DOCUMENT_RETURN_JAVASCRIPT
+
+  attr_reader :driver
+  attr_accessor :dimension
+  def initialize(driver, dimension=nil)
+    @driver = driver
+    @dimension = dimension
+  end
+
+  def extract_viewport_width
+     begin
+       return driver.execute_script(GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_NORMAL_BROWSER)
+     rescue => e 
+       EyesLogger.info "getViewportSize(): Browser does not support innerWidth (#{e.message})"
+     end
+
+    driver.execute_script(GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_BAD_BROWSERS)
+  end
+
+  def extract_viewport_height
+     begin
+       return driver.execute_script(GET_VIEWPORT_HEIGHT_JAVASCRIPT_FOR_NORMAL_BROWSER)
+     rescue  => e 
+       EyesLogger.info "getViewportSize(): Browser does not support innerHeight (#{e.message})"
+     end
+
+    driver.execute_script(GET_VIEWPORT_WIDTH_JAVASCRIPT_FOR_BAD_BROWSERS)
+  end
+
+  def extract_viewport_from_browser!
+    self.dimension = extract_viewport_from_browser
+  end
+
+  def extract_viewport_from_browser
+    width  = extract_viewport_width 
+    height = extract_viewport_height
+    Applitools::Dimension.new(width,height)
+  rescue => e
+    EyesLogger.info "getViewportSize(): only window size is available (#{e.message})"
+    width, height = *browser_size.values
+    Applitools::Dimension.new(width,height)
+  end
+  alias_method :viewport_size, :extract_viewport_from_browser
+
+  def set
+    if dimension.is_a?(Hash) && dimension.has_key?(:width) && dimension.has_key?(:height)
+      # If dimension is hash of width/height, we convert it to a struct with width/height properties.
+      self.dimension = Struct.new(:width, :height).new(dimension[:width], dimension[:height])
+    elsif !dimension.respond_to?(:width) || !dimension.respond_to?(:height)
+      raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class}" +
+                           " to respond to #width and #height, or be a hash with these keys"
+    end
+    self.browser_size = dimension
+    verify_size(:browser_size)
+    cur_viewport_size = extract_viewport_from_browser
+    self.browser_size = Applitools::Dimension.new(
+                          (2 * browser_size.width) - cur_viewport_size.width,
+                          (2 * browser_size.height) - cur_viewport_size.height
+                        )
+    verify_size(:viewport_size)
+  end
+
+  def verify_size(to_verify, sleep_time=1, retries=3)
+    retries.times do
+      sleep(sleep_time) 
+      cur_size = send(to_verify)
+      return if cur_size.values == dimension.values
+    end
+    EyesLogger.info(err_msg = "Failed setting #{to_verify} to #{dimension.values}")
+    raise Applitools::TestFailedError.new(err_msg)
+  end
+
+  def browser_size
+    driver.manage.window.size
+  end
+
+  def browser_size=(other)
+    self.driver.manage.window.size = other
+  end
+
+  def to_hash
+    Hash[dimension.each_pair.to_a]
+  end
+end

data/lib/eyes_selenium/eyes_logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module EyesLogger
+  def self.logger(to=STDOUT, level=Logger::INFO)
+    return @@log if defined?(@@log)
+    @@log = Logger.new(to)
+    @@log.level = level
+    @@log
+  end
+
+  def self.info(msg)
+    logger.info(msg)
+  end
+
+  def self.debug(msg)
+    logger.debug(msg)
+  end
+end

data/lib/eyes_selenium/utils.rb

@@ -0,0 +1,5 @@
+module Applitools
+  module Utils
+    require 'eyes_selenium/utils/image_delta_compressor'
+  end
+end

data/lib/eyes_selenium/utils/image_delta_compressor.rb

@@ -0,0 +1,147 @@
+=begin
+Applitools SDK class.
+
+Provides image compression based on image sequences and deflate
+=end
+require 'oily_png'
+require 'base64'
+
+class Applitools::Utils::ImageDeltaCompressor
+
+  # Compresses the target image based on the source image.
+  # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
+  # +target_encoded+:: +Array+ The uncompressed image as binary string.
+  # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
+  # +block_size+:: +Integer+ The width/height of each block.
+  # ++
+  # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
+  # is greater in length)
+  def self.compress_by_raw_blocks(target, target_encoded, source, block_size = 10)
+    # If we can't compress for any reason, return the target image as is.
+    if source.nil? || (source.height != target.height) || (source.width != target.width)
+      # Returning a COPY of the target binary string
+      return String.new(target_encoded) 
+    end
+
+    # Preparing the variables we need
+    target_pixels = target.to_rgb_stream.unpack('C*')
+    source_pixels = source.to_rgb_stream.unpack('C*')
+    image_size = Dimension.new(target.width, target.height)
+    block_columns_count = (target.width / block_size) + ((target.width % block_size) == 0 ? 0 : 1)
+    block_rows_count = (target.height / block_size) + ((target.height % block_size) == 0 ? 0 : 1)
+
+    # IMPORTANT: The "-Zlib::MAX_WBITS" tells ZLib to create raw deflate compression, without the
+    # "Zlib headers" (this isn't documented in the Zlib page, I found this in some internet forum).
+    compressor = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS)
+
+    compression_result = ''
+
+    # Writing the data header
+    compression_result += @@PREAMBLE.encode("UTF-8")
+    compression_result += [@@FORMAT_RAW_BLOCKS].pack("C")
+    compression_result += [0].pack("S>") #Source id, Big Endian
+    compression_result += [block_size].pack("S>") #Big Endian
+
+
+    # We perform the compression for each channel
+    3.times do |channel|
+      block_number = 0
+      block_rows_count.times do |block_row|
+        block_columns_count.times do |block_column|
+          actual_channel_index = 2 - channel # Since the image bytes are BGR and the server expects RGB...
+          compare_result = compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, 3, block_size,
+                                                               block_column, block_row, actual_channel_index)
+
+          if !compare_result.identical
+            channel_bytes = compare_result.channel_bytes
+            string_to_compress = [channel].pack('C')
+            string_to_compress += [block_number].pack('L>')
+            string_to_compress += channel_bytes.pack('C*')
+            compression_result += compressor.deflate(string_to_compress)
+
+            # If the compressed data so far is greater than the uncompressed
+            # representation of the target, just return the target.
+            if compression_result.length > target_encoded.length
+              compressor.close
+              # Returning a COPY of the target bytes
+              return String.new(target_encoded)
+            end
+          end
+          block_number += 1
+        end
+      end
+    end
+    # Compress and flush any remaining uncompressed data in the input buffer.
+    compression_result += compressor.finish
+    compressor.close
+    # Returning the compressed result as a byte array
+    return compression_result
+  end
+
+
+  ### PRIVATE
+  private
+
+  @@PREAMBLE = "applitools"
+  @@FORMAT_RAW_BLOCKS = 3
+
+  Dimension = Struct.new(:width, :height)
+  CompareAndCopyBlockChannelDataResult = Struct.new(:identical, :channel_bytes)
+
+
+  # Computes the width and height of the image data contained in the block
+  # at the input column and row.
+  # +image_size+:: +Dimension+ The image size in pixels.
+  # +block_size+:: The block size for which we would like to compute the image data width and height.
+  # +block_column+:: The block column index.
+  # +block_row+:: The block row index.
+  # ++
+  # Returns the width and height of the image data contained in the block are returned as a +Dimension+.
+  def self.get_actual_block_size(image_size, block_size, block_column, block_row)
+    actual_width = [image_size.width - (block_column * block_size), block_size].min
+    actual_height = [image_size.height - (block_row * block_size), block_size].min
+    Dimension.new(actual_width, actual_height)
+  end
+
+  # Compares a block of pixels between the source and target and copies the target's block bytes to the result.
+  # +source_pixels+:: +Array+ of bytes, representing the pixels of the source image.
+  # +target_pixels+:: +Array+ of bytes, representing the pixels of the target image.
+  # +image_size+:: +Dimension+ The size of the source/target image (remember they must be the same size).
+  # +pixel_length+:: +Integer+ The number of bytes composing a pixel
+  # +block_size+:: +Integer+ The width/height of the block (block is a square, theoretically).
+  # +block_column+:: +Integer+ The block column index (when looking at the images as a grid of blocks).
+  # +block_row+:: +Integer+ The block row index (when looking at the images as a grid of blocks).
+  # +channel+:: +Integer+ The index of the channel we're comparing.
+  # ++
+  # Returns +CompareAndCopyBlockChannelDataResult+ object containing a flag saying whether the blocks are identical
+  # and a copy of the target block's bytes.
+  def self.compare_and_copy_block_channel_data(source_pixels, target_pixels, image_size, pixel_length, block_size,
+      block_column, block_row, channel)
+    identical = true
+
+    actual_block_size = get_actual_block_size(image_size, block_size, block_column, block_row)
+
+    # Getting the actual amount of data in the block we wish to copy
+    actual_block_height = actual_block_size.height
+    actual_block_width = actual_block_size.width
+
+    stride = image_size.width * pixel_length
+
+    # Iterating the block's pixels and comparing the source and target
+    channel_bytes = []
+    actual_block_height.times do |h|
+      offset = (((block_size * block_row) + h) * stride) + (block_size * block_column * pixel_length) + channel
+      actual_block_width.times do |w|
+        source_byte = source_pixels[offset]
+        target_byte = target_pixels[offset]
+        if source_byte != target_byte
+          identical = false
+        end
+        channel_bytes << target_byte
+        offset += pixel_length
+      end
+    end
+    # Returning the compare-and-copy result
+    CompareAndCopyBlockChannelDataResult.new(identical, channel_bytes)
+  end
+end

data/lib/eyes_selenium/version.rb

@@ -0,0 +1,3 @@
+module Applitools
+  VERSION = "1.6.0"
+end

data/spec/capybara_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'capybara/rspec'
+require 'eyes_selenium/capybara'
+require 'test_app'
+
+Capybara.app = TestApp
+
+describe Applitools::Eyes do
+  init_eyes
+  describe 'capybara' do
+    before do
+      eyes.agent_connector.stub(:stop_session).and_return(double("TestResults", mismatches: 0, missing: 0))
+      eyes.agent_connector.stub(:match_window).and_return(true)
+      @navigation = double("navigation")
+      @navigation.stub(:to)
+    end
+    it 'should invoke eyes driver when calling capybara visit inside of eyes.open' do
+      Capybara.current_driver.should == :rack_test
+
+      eyes.driver.should_receive(:navigate).and_return(@navigation)
+      eyes.test(app_name: 'test', test_name: 'test') do |eyes|
+        Capybara.current_driver.should == :selenium
+        eyes.driver.should == Capybara.current_session.driver.instance_variable_get(:@browser)
+        Capybara.current_session.visit '/'
+        eyes.check_window('test')
+      end
+      Capybara.current_driver.should == :rack_test
+    end
+    it 'should not invoke eyes driver when calling capybara visit outside of eyes.open' do
+      eyes.driver.should_not_receive(:navigate)
+      Capybara.current_session.visit '/'
+    end
+  end
+end

data/spec/driver_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Applitools::Driver do
+  describe "#driver" do
+    let(:driver) { Applitools::Driver.new }
+
+    it "has a selenium driver" do
+    end
+  end
+end

data/spec/eyes_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Applitools::Eyes do
+  init_eyes
+
+  before do
+    eyes.open(app_name: 'test_app', test_name: 'test_app_test')
+    fake_session = Applitools::Session.new(1,"http://fake_url.com", false)
+    eyes.session = fake_session
+    eyes.agent_connector.stub(:stop_session).and_return(double("TestResults", mismatches: 0, missing: 0))
+    eyes.agent_connector.stub(:match_window).and_return(true)
+  end
+
+  describe "#new" do
+    context "doesn't have an apikey" do
+      before do
+        Applitools::Eyes.config[:apikey] = nil
+      end
+      it {expect {Applitools::Eyes.new }.to raise_error }
+      after do
+        Applitools::Eyes.config[:apikey] = 'YOUR_API_KEY_HERE'
+      end
+    end
+    context "has an apikey url" do
+      it {expect {Applitools::Eyes.new }.to_not raise_error }
+    end
+  end
+
+  describe ".open" do
+    context "already open" do
+      it "aborts session" do
+        eyes.should_receive(:abort_if_not_closed)
+        expect {eyes.open}.to raise_error
+      end
+    end
+
+  end
+
+  describe ".abort_if_not_closed" do
+    it "closes eyes" do
+      expect(eyes).to be_open
+      eyes.send(:abort_if_not_closed)
+      expect(eyes).to_not be_open
+    end
+
+    it "clears session" do
+      eyes.send(:abort_if_not_closed)
+      expect(eyes.session).to be_nil
+    end
+
+    it "stops session" do
+      expect(eyes.agent_connector).to receive(:stop_session)
+      eyes.send(:abort_if_not_closed)
+    end
+  end
+
+  describe ".close" do
+    it "stops the session" do
+      eyes.agent_connector.stub(:stop_session).and_return(double("TestResults", mismatches: 0, missing: 0))
+      expect(eyes.agent_connector).to receive(:stop_session)
+      expect(eyes.close)
+    end
+
+    context "new_session" do
+      before { eyes.session.stub(:new_session?).and_return(true) }
+      it "raises NewTestError" do
+        eyes.session_start_info = double().as_null_object
+        expect { eyes.close }.to raise_error(Applitools::NewTestError)
+      end
+    end
+
+    context "not new_session" do
+      before do
+        eyes.stub(:session_start_info).and_return double().as_null_object 
+        eyes.session.new_session = false
+      end
+
+      it "raises TestFailedError if results have mismatches" do
+        eyes.agent_connector.stub(:stop_session).and_return(double("TestResults", mismatches: 2))
+        expect { eyes.close }.to raise_error(Applitools::TestFailedError)
+      end
+
+      it "raises TestFailedError if results have missing" do
+        eyes.agent_connector.stub(:stop_session).and_return(double("TestResults", mismatches: 0, missing: 2))
+        expect { eyes.close }.to raise_error(Applitools::TestFailedError)
+      end
+
+      it "doesn't raise if old session without mismatches" do
+        eyes.stub_chain(:agent_connector, :stop_session).and_return(double("TestResults", mismatches: 0, missing: 0))
+        expect(eyes.close).to_not raise_error
+      end
+    end
+  end
+
+  describe ".check_window" do
+    it "raises EyesError if eyes aren't open"
+    context "no session" do 
+      it "creates new session if no session exists"
+      it "creates new MatchWindowTask"
+    end
+
+    context "results are as expected" do
+      it "doesn't raise"
+    end
+    context "results are not as expected" do
+      context "new session" do
+        specify "next check_window will run once on time out"
+      end
+      context "not new session" do
+        context "immediate failreports" do
+          it "raises TestFailedError"
+        end
+
+        context "not immediate failreports" do
+          it "doesn't raise"
+        end
+      end
+    end
+  end
+
+  describe ".test" do
+    it "opens and closes the eyes around the block execution" do
+      eyes.should_receive(:open).ordered
+      eyes.should_receive(:close).ordered
+      eyes.test { "foo" }
+    end
+
+    it "always closes eyes even if there were exceptions" do
+      eyes.stub(:open)
+      eyes.should_receive(:abort_if_not_closed)
+      eyes.test { raise Applitools::EyesError }
+    end
+
+    context "testing .test" do
+      let!(:eyes) do
+        Applitools::Eyes.new
+      end
+      it "catches triggers" do
+        eyes.send(:abort_if_not_closed)
+        eyes.test(app_name: 'my app1', test_name: 'my test') do |eyes, driver|
+          driver.get "http://www.applitools.com"
+          eyes.check_window("initial")
+          driver.find_element(:css, "li.pricing a").click
+          # return false unless user_inputs.map(&:to_hash) == [{"$type"=>"Applitools.Models.MouseTrigger, Core", :mouseAction=>1, :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>555, :top=>0, :height=>69, :width=>50}, :location=>{:latitude=>25, :longitude=>34, :altitude=>nil}}]
+          eyes.check_window("pricing page")
+          el = driver.find_elements(:css, ".footer-row a").first
+          driver.action.double_click(el).perform
+          # return false unless user_inputs.map(&:to_hash) == [{"$type"=>"Applitools.Models.MouseTrigger, Core", :mouseAction=>3, :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>0, :top=>0, :height=>115, :width=>376}, :location=>{:x=>115, :y=>376}}]
+          eyes.check_window("in forms")
+          other_el = driver.find_elements(:css, ".s2member-pro-paypal-registration-email").first
+          driver.action.move_to(other_el).click(other_el).send_keys("text1",:space,"text2").perform
+          # return false unless user_inputs.map(&:to_hash) == [{"$type"=>"Applitools.Models.MouseTrigger, Core", :mouseAction=>4, :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>0, :top=>0, :height=>230, :width=>331}, :location=>{:x=>230, :y=>331}}, {"$type"=>"Applitools.Models.MouseTrigger, Core", :mouseAction=>1, :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>0, :top=>0, :height=>230, :width=>331}, :location=>{:x=>230, :y=>331}}, {"$type"=>"Applitools.Models.TextTrigger, Core", :text=>"text1", :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>230, :top=>331, :height=>367, :width=>35}}, {"$type"=>"Applitools.Models.TextTrigger, Core", :text=>"", :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>230, :top=>331, :height=>367, :width=>35}}, {"$type"=>"Applitools.Models.TextTrigger, Core", :text=>"text2", :control=>{"$type"=>"Applitools.Utils.Geometry.MutableRegion, Core", :left=>230, :top=>331, :height=>367, :width=>35}}]
+        end
+      end
+    end
+  end
+end