eyes_selenium_ruby 1.1.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,66 @@
+# Applitools
+
+Applitools Ruby SDK.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eyes_selenium_ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eyes_selenium_ruby
+
+## 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
+Applitools::Eyes.config[:apikey] = 'XXX'
+```
+
+spec:
+```ruby
+require 'eyes_selenium_ruby/capybara'
+
+describe 'some test'
+  let(:eyes) do
+    Applitools::Eyes.new
+  end
+  it 'should navigate from home page to pricing page'
+    eyes.test(app_name: 'my app', test_name: 'my test') do |eyes|
+      visit root_path
+      page.should have_content('login')
+      eyes.check_window('home page')
+      click_link 'Pricing'
+      eyes.check_window('pricing')
+      page.should have_content('gold')
+    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_ruby.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_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eyes_selenium_ruby"
+  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.0"]
+  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_ruby/capybara.rb

@@ -0,0 +1,21 @@
+require 'eyes_selenium_ruby'
+
+# 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_ruby/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_ruby/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_ruby/eyes/driver.rb

@@ -0,0 +1,145 @@
+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
+    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_ruby/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

data/lib/eyes_selenium_ruby/eyes/environment.rb

@@ -0,0 +1,13 @@
+class Applitools::Environment
+
+  attr_accessor :os, :hosting_app, :display_size
+  def initialize(os=nil, hosting_app=nil, display_size=nil)
+    @os = os
+    @hosting_app = hosting_app
+    @display_size = display_size
+  end
+
+  def to_hash
+    { os: os, hostingApp: hosting_app, displaySize: Hash[display_size.each_pair.to_a] }
+  end
+end

data/lib/eyes_selenium_ruby/eyes/eyes.rb

@@ -0,0 +1,179 @@
+class Applitools::Eyes
+  DEFAULT_MATCH_TIMEOUT = 2.0
+
+  class << self
+    attr_accessor :config
+  end
+
+  @config = {
+    server_url: 'https://eyes.applitools.com',
+    user: 'eyes.selenium.ruby'
+    # apikey: 'please supply an apikey in your initializer'
+  }
+
+  attr_reader :agent_connector, :disabled
+  attr_accessor :app_name, :test_name, :session, :is_open, :aborted, :viewport_size, :match_timeout, 
+                :failure_reports, :test_batch, :match_level, :driver, :host_os, :host_app, :branch_name, :parent_branch_name, 
+                :should_match_window_run_once_on_timeout, :session_start_info, :match_window_task
+
+  def config
+    self.class.config
+  end
+
+  def initialize(params={})
+    raise "Please supply an apikey: Eyes.config[:apikey] = ..." unless config[:apikey]
+
+    @disabled = params[:disabled]
+
+    @driver = create_driver(params)
+    return if disabled?
+
+    @agent_connector = Applitools::AgentConnector.new(config[:server_url], config[:user], config[:apikey])
+    @match_timeout = DEFAULT_MATCH_TIMEOUT
+    @failure_reports = Applitools::FailureReports::ON_CLOSE
+  end
+
+  def create_driver(params)
+    Applitools::Driver.new(browser: params.fetch(:browser, nil))
+  end
+
+  def open(params={})
+    return driver if disabled?
+
+    if open?
+      abort_if_not_closed
+      msg = 'a test is alread running'
+      EyesLogger.info(msg) and raise Applitools::EyesError.new(msg)
+    end
+
+    self.app_name = params.fetch(:app_name)
+    self.failure_reports = params.fetch(:failure_reports, self.failure_reports)
+    self.match_level = params.fetch(:match_level,MatchLevel::EXACT)
+    self.test_name = params.fetch(:test_name)
+    self.viewport_size = params.fetch(:view_port_size, nil)
+
+    self.is_open = true
+    driver
+  end
+
+  def open?
+    self.is_open
+  end
+
+  def check_window(tag)
+    return if disabled?
+    raise Applitools::EyesError.new("Eyes not open") if !open?
+    if !session
+      start_session
+      self.match_window_task = Applitools::MatchWindowTask.new(agent_connector, session, driver, match_timeout)
+    end
+
+    as_expected = match_window_task.match_window(tag, should_match_window_run_once_on_timeout)
+    if !as_expected
+      self.should_match_window_run_once_on_timeout = true
+      if !session.new_session?
+        EyesLogger.info %( "mismatch! #{ tag ? "" : "(#{tag})" } )
+        if failure_reports.to_i == Applitools::FailureReports::IMMEDIATE
+          raise Applitools::TestFailedError.new("Mismatch found in '#{start_info.scenario_id_or_name}'"\
+                                                " of '#{start_info.app_id_or_name}'")
+        end
+      end
+    end
+  end
+
+  def close
+    return if disabled?
+    self.is_open = false
+    return Applitools::TestResults.new if !session
+
+    session_results_url = session.url
+    results = agent_connector.stop_session(session,false)
+    new_session = session.new_session?
+    self.session = nil
+
+    if new_session
+      instructions = "Please approve the new baseline at #{session_results_url}"
+      EyesLogger.info "--- New test ended.  #{instructions}"
+      message = "' #{session_start_info.scenario_id_or_name} of"\
+                " #{session_start_info.app_id_or_name}. #{instructions}"
+      raise Applitools::NewTestError.new(message, results)
+    elsif 0 < results.mismatches || 0 < results.missing 
+      EyesLogger.info "--- Failed test ended. See details at #{session_results_url}"
+      message = "' #{session_start_info.scenario_id_or_name} of"\
+                " #{session_start_info.app_id_or_name}'. See details at #{session_results_url}"
+      raise Applitools::TestFailedError.new(message, results)
+    end
+
+    EyesLogger.info "--- Test passed. See details at #{session_results_url}"
+  end
+
+  ## Use this method to perform seamless testing with selenium through eyes driver.
+  ## Using Selenium methods inside the 'test' block will send the messages to Selenium
+  ## after creating the Eyes triggers for them.
+  ##
+  ## Example:
+  #    eyes.test(app_name: 'my app1', test_name: 'my test') do |d|
+  #      get "http://www.google.com"
+  #      check_window("initial")
+  #    end
+  def test(params={}, &block)
+    begin
+      open(params)
+      yield(self, driver)
+      close
+    rescue Applitools::EyesError
+    ensure 
+      abort_if_not_closed
+    end
+  end
+
+
+    def abort_if_not_closed
+      return if disabled?
+      self.is_open = false
+      if session
+        begin
+          agent_connector.stop_session(session,true)
+        rescue Applitools::EyesError => e
+          EyesLogger.info "Failed to abort server session -> #{e.message} "
+        ensure
+          self.session = nil
+        end
+      end
+    end
+
+  private
+
+    def disabled? 
+      disabled
+    end
+
+    def start_session
+      assign_viewport_size
+      test_batch ||= Applitools::BatchInfo.new
+      app_env = Applitools::Environment.new(host_os, host_app, viewport_size)
+      application = driver.create_application
+      self.session_start_info = Applitools::StartInfo.new(
+        app_name, test_name, test_batch, app_env, application, 
+        match_level,nil, branch_name, parent_branch_name
+      )
+      self.session = agent_connector.start_session(session_start_info)
+      self.should_match_window_run_once_on_timeout = session.new_session?
+    end
+
+    def viewport_size?
+      self.viewport_size
+    end
+
+    def assign_viewport_size
+      if viewport_size?
+        self.viewport_size = Applitools::ViewportSize.new(driver, viewport_size).set
+      else
+        self.viewport_size =  Applitools::ViewportSize.new(driver).extract_viewport_from_browser!
+      end
+    end
+
+    def to_hash
+      Hash[dimension.each_pair.to_a]
+    end
+end

data/lib/eyes_selenium_ruby/eyes/eyes_keyboard.rb

@@ -0,0 +1,25 @@
+class Applitools::EyesKeyboard
+  attr_reader :keyboard, :driver
+  
+  def initialize(driver, keyboard)
+    @driver = driver
+    @keyboard = keyboard
+  end
+
+  def send_keys(*keys)
+    active_element = Applitools::Element.new(driver, driver.switch_to.active_element)
+    current_control = active_element.region
+    Selenium::WebDriver::Keys.encode(keys).each do |key|
+      driver.user_inputs << Applitools::TextTrigger.new(key.to_s, current_control)
+    end
+    keyboard.send_keys(*keys)
+  end
+
+  def press(key)
+    keyboard.press(key)
+  end
+
+  def release(key)
+    keyboard.release(key)
+  end
+end