eyes_selenium 1.6.0

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2013 Applitools
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,82 @@
+# Applitools
+
+Applitools Ruby SDK.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eyes_selenium'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eyes_selenium
+
+## Standalone Usage
+
+```ruby
+Applitools::Eyes.config[:apikey] = 'XXX'
+
+eyes = Applitools::Eyes.new
+eyes.test(app_name: 'my app', test_name: 'my test') do |eyes, driver|
+  driver.get 'http://www.mywebsite.com'
+  eyes.check_window('home page')
+  driver.find_element(:css, "li#pricing").click
+  eyes.check_window('pricing')
+end
+```
+
+## Integrated within your Capybara tests:
+initializer:
+```ruby
+Capybara.run_server = false
+# This is your api key, make sure you use it in all your tests.
+Applitools::Eyes.config[:apikey] = 'XXX'
+let(:eyes) do
+  webdriver = page.driver.browser
+  eyes = Applitools::Eyes.new browser: webdriver
+end
+```
+
+spec:
+```ruby
+require 'capybara/rspec'
+require 'eyes_selenium_ruby'
+
+
+describe 'Applitools', :type=>:feature, :js=>true do
+
+  describe 'Test Applitools website' do
+    it 'should navigate from the main page to the features page' do
+
+      # Start visual testing with browser viewport set to 1024x768.
+      eyes.open(app_name: 'Applitools', test_name: 'Test Web Page', viewport_size: {width: 1024, height: 768})
+
+      visit 'http://www.applitools.com'
+
+      # Visual validation point #1
+      eyes.check_window('Main Page')
+
+      page.first('.read_more').click
+
+      # Visual validation point #2
+      eyes.check_window('Features Page')
+
+      eyes.close()
+    end
+  end
+end
+
+```
+
+## Contributing
+
+1. Fork it
+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/eyes_selenium.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eyes_selenium/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eyes_selenium"
+  spec.version       = Applitools::VERSION
+  spec.authors       = ["Applitools team"]
+  spec.email         = ["team@applitools.com"]
+  spec.description   = "Applitools Ruby SDK"
+  spec.summary       = "Applitools Ruby SDK"
+  spec.homepage      = "http://www.applitools.com"
+  spec.license       = "Apache License, Version 2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "selenium-webdriver", [">= 2.37"]
+  spec.add_dependency "httparty" 
+  spec.add_dependency "oily_png", [">= 1.1.0"] 
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", [">= 2.2.0"]
+  spec.add_development_dependency "capybara", [">= 2.1.0"]
+  spec.add_development_dependency "sinatra"
+end

data/lib/eyes_selenium.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'eyes_selenium/eyes_logger'
+require 'json'
+module Applitools
+  include EyesLogger
+  class EyesError < StandardError; end
+  class EyesAbort < EyesError; end
+
+  class TestFailedError < StandardError
+    attr_accessor :test_results
+    def initialize(message, test_results=nil)
+      super(message)
+      @test_results = test_results
+    end
+  end
+  class NewTestError < TestFailedError; end
+
+  require 'eyes_selenium/utils'
+  require "eyes_selenium/eyes/agent_connecter"
+  require "eyes_selenium/eyes/target_app"
+  require 'eyes_selenium/eyes/batch_info'
+  require "eyes_selenium/eyes/dimension"
+  require "eyes_selenium/eyes/driver"
+  require 'eyes_selenium/eyes/element'
+  require 'eyes_selenium/eyes/environment'
+  require 'eyes_selenium/eyes/eyes'
+  require 'eyes_selenium/eyes/eyes_keyboard'
+  require 'eyes_selenium/eyes/eyes_mouse'
+  require 'eyes_selenium/eyes/failure_reports'
+  require 'eyes_selenium/eyes/match_level'
+  require 'eyes_selenium/eyes/match_window_data'
+  require 'eyes_selenium/eyes/match_window_task'
+  require 'eyes_selenium/eyes/mouse_trigger'
+  require 'eyes_selenium/eyes/region'
+  require 'eyes_selenium/eyes/screenshot_taker'
+  require 'eyes_selenium/eyes/session'
+  require 'eyes_selenium/eyes/start_info'
+  require 'eyes_selenium/eyes/test_results'
+  require 'eyes_selenium/eyes/text_trigger'
+  require "eyes_selenium/version"
+  require 'eyes_selenium/eyes/viewport_size'
+end

data/lib/eyes_selenium/capybara.rb

@@ -0,0 +1,21 @@
+require 'eyes_selenium'
+
+# Override create driver to inject into capybara's driver
+class Applitools::Eyes
+  def test(params={}, &block)
+    begin
+      previous_driver = Capybara.current_driver
+      previous_browser = Capybara.current_session.driver.instance_variable_get(:@browser)
+      Capybara.current_driver = :selenium
+      Capybara.current_session.driver.instance_variable_set(:@browser, driver)
+      open(params)
+      yield(self, driver)
+      close
+    rescue Applitools::EyesError
+    ensure 
+      abort_if_not_closed
+      Capybara.current_session.driver.instance_variable_set(:@browser, previous_browser)
+      Capybara.current_driver = previous_driver
+    end
+  end
+end

data/lib/eyes_selenium/eyes/agent_connecter.rb

@@ -0,0 +1,39 @@
+require 'httparty'
+class Applitools::AgentConnector
+  include HTTParty
+  headers 'Accept' => 'application/json'
+  #debug_output $stdout # comment out when not debugging
+
+  attr_reader :uri, :auth
+  def initialize(base_uri, username, password)
+    # Remove trailing slashes in base uri and add the running sessions endpoint uri.
+    @uri = base_uri.gsub(/\/$/,"") + "/api/sessions/running"
+    @auth = { username: username, password: password }
+  end
+
+  def match_window(session, data)
+    self.class.headers 'Content-Type' => 'application/octet-stream'
+    json_data = data.to_hash.to_json.encode('UTF-8') # Notice that this does not include the screenshot
+    body = [json_data.length].pack('L>') + json_data + data.screenshot
+
+    res = self.class.post(uri + "/#{session.id}",basic_auth: auth, body: body)
+    raise Applitools::EyesError.new("could not connect to server") if res.code != 200
+    res.parsed_response["asExpected"]
+  end
+
+  def start_session(session_start_info)
+   self.class.headers 'Content-Type' => 'application/json'
+   res = self.class.post(uri, basic_auth: auth, body: { startInfo: session_start_info.to_hash }.to_json)
+   status_code = res.response.message
+   parsed_res = res.parsed_response
+   Applitools::Session.new(parsed_res["id"], parsed_res["url"], status_code == "Created" )
+  end
+
+  def stop_session(session, aborted=nil)
+    self.class.headers 'Content-Type' => 'application/json'
+    res = self.class.delete(uri + "/#{session.id}", basic_auth: auth, params: { aborted: aborted.to_s })
+    parsed_res = res.parsed_response
+    parsed_res.delete("$id")
+    Applitools::TestResults.new(*parsed_res.values)
+  end
+end

data/lib/eyes_selenium/eyes/batch_info.rb

@@ -0,0 +1,14 @@
+class Applitools::BatchInfo
+  attr_reader :name, :started_at
+  def initialize(name=nil, started_at = Time.now)
+    @name = name
+    @started_at = started_at
+  end
+
+  def to_hash
+    {
+      name: name,
+      startedAt: started_at.iso8601
+    }
+  end
+end

data/lib/eyes_selenium/eyes/dimension.rb

@@ -0,0 +1,15 @@
+class Applitools::Dimension
+
+  attr_accessor :width, :height
+  def initialize(width, height)
+    @width = width
+    @height = height
+  end
+
+  def to_hash
+    { width: width, height: height}
+  end
+  def values
+    [width, height]
+  end
+end

data/lib/eyes_selenium/eyes/driver.rb

@@ -0,0 +1,146 @@
+require 'socket'
+require 'selenium-webdriver'
+class  Applitools::Driver
+
+  include Selenium::WebDriver::DriverExtensions::HasInputDevices
+
+  attr_reader :remote_server_url, :remote_session_id, :user_agent, :screenshot_taker
+  attr_accessor :user_inputs, :browser
+
+  DEFAULT_DRIVER = :firefox
+  DRIVER_METHODS = [
+    :title, :execute_script, :execute_async_script, :quit, :close, :get,
+    :post, :page_source, :window_handles, :window_handle, :switch_to, 
+    :navigate, :manage, :capabilities
+  ]
+
+  ## If driver is not provided, Applitools::Driver will default to Firefox driver
+  ## Driver param can be a Selenium::WebDriver or a named symbol (:chrome)
+  #
+  ## Example:
+  #  eyes.open(browser: :chrome) ##=> will create chrome webdriver
+  #  eyes.open(browser: Selenium::WebDriver.for(:chrome) ##=> will create the same thing
+  #  eyes.open ##=> will create a webdriver according to Applitools::Driver::DEFAULT_DRIVER
+  def initialize(options={})
+    browser_obj = options.delete(:browser) || DEFAULT_DRIVER 
+    @browser ||= case browser_obj
+                 when Symbol
+                   Selenium::WebDriver.for browser_obj
+                 else
+                   browser_obj
+                 end
+    # TODO Remove this if all is good. We don't want to call 'quit' everytime the object is destroyed, we might still want to use the underlying driver
+    #at_exit { quit rescue nil }
+
+    @user_inputs = []
+    @remote_server_url = address_of_remote_server
+    @remote_session_id = remote_session_id
+    @user_agent = get_user_agent
+    begin
+      if browser.capabilities.takes_screenshot?
+       @screenshot_taker = false
+      else
+        @screenshot_taker = Applitools::ScreenshotTaker.new(@remote_server_url, @remote_session_id)
+      end
+    rescue => e 
+      raise Applitools::EyesError.new "Can't take screenshots (#{e.message})"
+    end
+  end
+
+  DRIVER_METHODS.each do |method|
+    define_method method do |*args, &block|
+      browser.send(method,*args, &block)
+    end
+  end
+
+  def screenshot_as(output_type)
+    return browser.screenshot_as(output_type) if !screenshot_taker
+
+    if output_type.downcase.to_sym != :base64
+      raise Applitools::EyesError.new("#{output_type} ouput type not supported for screenshot")
+    end
+    screenshot_taker.screenshot
+  end 
+
+  def mouse
+    Applitools::EyesMouse.new(self, browser.mouse)
+  end
+
+  def keyboard
+    Applitools::EyesKeyboard.new(self, browser.keyboard)
+  end
+
+  def find_element(by, selector)
+    Applitools::Element.new(self, browser.find_element(by, selector))
+  end
+
+  def find_elements(by, selector)
+    browser.find_elements(by, selector).map { |el| Applitools::Element.new(self, el) }
+  end
+
+  def create_application
+    Applitools::TargetApp.new(remote_server_url, remote_session_id, user_agent)
+  end
+
+  def clear_user_inputs
+    user_inputs.clear
+  end
+
+  def ie?
+    browser.to_s == 'ie'
+  end
+
+  def firefox?
+    browser.to_s == 'firefox'
+  end
+
+  private
+
+    def address_of_remote_server
+      uri = URI(browser.current_url)
+      raise Applitools::EyesError.new("Failed to get remote web driver url") if uri.to_s.empty?
+
+      webdriver_host = uri.host
+      if ['127.0.0.1', 'localhost'].include?(webdriver_host) && !firefox? && !ie?
+        uri.host = get_local_ip || 'localhost'
+      end
+
+      uri
+    end
+
+    def remote_session_id
+      browser.remote_session_id
+    end
+
+    def get_user_agent
+      execute_script "return navigator.userAgent"
+    rescue => e
+      puts "getUserAgent(): Failed to obtain user-agent string (#{e.message})"
+    end
+    
+    def get_local_ip
+      begin
+        Socket.ip_address_list.detect do |intf| 
+          intf.ipv4? and !intf.ipv4_loopback? and !intf.ipv4_multicast?
+        end.ip_address
+      rescue SocketError => e
+        raise Applitools::EyesError.new("Failed to get local IP! (#{e})")
+      end
+    end
+
+end
+
+## .bridge, .session_id and .server_url are private methods in Selenium::WebDriver gem
+module Selenium::WebDriver
+  class Driver
+    def remote_session_id
+      bridge.session_id
+    end
+  end
+
+  class Remote::Http::Common
+    def get_server_url
+      server_url
+    end
+  end
+end

data/lib/eyes_selenium/eyes/element.rb

@@ -0,0 +1,78 @@
+class Applitools::Element
+  attr_accessor :driver, :web_element
+
+  ELEMENT_METHODS = [ 
+    :hash, :id, :id=, :bridge=, :submit, :clear, :tag_name, :attribute,
+    :selected?, :enabled?, :displayed?, :text, :css_value, :find_element,
+    :find_elements, :location, :size, :location_once_scrolled_into_view,
+    :ref, :to_json, :as_json
+                ]
+
+  ELEMENT_METHODS.each do |method|
+    define_method method do |*args, &block|
+      web_element.send(method,*args, &block)
+    end
+  end
+  alias_method :style, :css_value  
+  alias_method :first, :find_element
+  alias_method :all, :find_elements
+  alias_method :[], :attribute
+
+
+
+  def initialize(driver, element)
+    @driver = driver
+    @web_element = element
+  end
+
+  def click
+    current_control = region
+    offset = current_control.middle_offset
+    driver.user_inputs << Applitools::MouseTrigger.new(:click, current_control, offset)
+
+    web_element.click
+  end
+
+  def inspect
+    "EyesWebElement" + web_element.inspect
+  end
+
+  def ==(other)
+    other.kind_of?(web_element.class) && web_element == other
+  end
+  alias_method :eql?, :==
+
+  def send_keys(*args)
+    current_control = region
+    Selenium::WebDriver::Keys.encode(args).each do |key|
+      driver.user_inputs << Applitools::TextTrigger.new(key.to_s, current_control)
+    end
+
+    web_element.send_keys(args)
+  end
+  alias_method :send_key, :send_keys
+
+  def region
+    point = location
+    left, top, width, height  = point.x, point.y, 0, 0
+
+    begin
+      dimension = size
+      width, height = dimension.width, dimension.height 
+    rescue
+      # Not supported on all platforms.
+    end
+
+    if left < 0 
+      width = [0, width + left].max
+      left = 0
+    end
+
+    if top < 0
+      height = [0, height + top].max
+      top = 0
+    end
+
+    return Applitools::Region.new(left, top, width, height)
+  end
+end