watir 5.0.0 → 6.0.0.beta1

data/spec/element_spec.rb

@@ -0,0 +1,136 @@
+require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
+
+describe Watir::Element do
+
+  describe '#present?' do
+    before do
+      browser.goto(WatirSpec.url_for("wait.html"))
+    end
+
+    it 'returns true if the element exists and is visible' do
+      expect(browser.div(:id, 'foo')).to be_present
+    end
+
+    it 'returns false if the element exists but is not visible' do
+      expect(browser.div(:id, 'bar')).to_not be_present
+    end
+
+    it 'returns false if the element does not exist' do
+      expect(browser.div(:id, 'should-not-exist')).to_not be_present
+    end
+
+    it "returns false if the element is stale" do
+      wd_element = browser.div(id: "foo").wd
+
+      # simulate element going stale during lookup
+      allow(browser.driver).to receive(:find_element).with(:id, 'foo') { wd_element }
+      browser.refresh
+
+      expect(browser.div(:id, 'foo')).to_not be_present
+    end
+
+  end
+
+  describe "#enabled?" do
+    before do
+      browser.goto(WatirSpec.url_for("forms_with_input_elements.html"))
+    end
+
+    it "returns true if the element is enabled" do
+      expect(browser.element(name: 'new_user_submit')).to be_enabled
+    end
+
+    it "returns false if the element is disabled" do
+      expect(browser.element(name: 'new_user_submit_disabled')).to_not be_enabled
+    end
+
+    it "raises UnknownObjectException if the element doesn't exist" do
+      expect { browser.element(name: "no_such_name").enabled? }.to raise_error(Watir::Exception::UnknownObjectException)
+    end
+  end
+
+  describe "#reset!" do
+    it "successfully relocates collection elements after a reset!" do
+      browser.goto(WatirSpec.url_for("wait.html"))
+      element = browser.div(id: 'foo')
+      expect(element).to exist
+      browser.refresh
+      browser.div(id: 'foo').wait_until_present
+
+      expect(element.exist?).to be false unless Watir.always_locate?
+      element.send :reset!
+      expect(element).to exist
+    end
+  end
+
+  describe "#exists?" do
+    before do
+      browser.goto WatirSpec.url_for('removed_element.html')
+    end
+
+    it "returns false when an element from a collection becomes stale" do
+      watir_element = browser.divs(id: "text").first
+      expect(watir_element).to exist
+
+      browser.refresh
+
+      expect(watir_element).to_not exist
+    end
+
+  end
+
+  describe "#element_call" do
+
+    it 'handles exceptions when taking an action on an element that goes stale during execution' do
+      browser.goto WatirSpec.url_for('removed_element.html')
+
+      watir_element = browser.div(id: "text")
+
+        # simulate element going stale after assert_exists and before action taken
+      allow(watir_element).to receive(:text) do
+        watir_element.send :assert_exists
+        browser.refresh
+        watir_element.send(:element_call) { watir_element.instance_variable_get('@element').text }
+      end
+
+      if Watir.always_locate?
+        expect { watir_element.text }.to_not raise_error
+      else
+        expect { watir_element.text }.to raise_error Watir::Exception::UnknownObjectException
+      end
+    end
+
+  end
+
+  bug "Actions Endpoint Not Yet Implemented", :firefox do
+    describe "#hover" do
+      not_compliant_on :internet_explorer, :safari do
+        it "should hover over the element" do
+          browser.goto WatirSpec.url_for('hover.html')
+          link = browser.a
+
+          expect(link.style("font-size")).to eq "10px"
+          link.hover
+          expect(link.style("font-size")).to eq "20px"
+        end
+      end
+    end
+  end
+
+  # TODO - Can remove when decide issue #295
+  describe "warnings" do
+    it "does not return a warning if using text_field for an unspecified text input" do
+       browser.goto(WatirSpec.url_for("forms_with_input_elements.html"))
+      expect do
+       browser.text_field(id: "new_user_first_name").exists?
+      end.to_not output.to_stderr
+    end
+
+    it "returns a warning if using text_field for textarea" do
+      browser.goto(WatirSpec.url_for("forms_with_input_elements.html"))
+      expect do
+        browser.text_field(id: "create_user_comment").exists?
+      end.to output.to_stderr
+    end
+  end
+end

data/spec/implementation.rb

@@ -0,0 +1,216 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+class ImplementationConfig
+  def initialize(imp)
+    @imp = imp
+  end
+
+  def browser
+    @browser ||= (ENV['WATIR_BROWSER'] || :chrome).to_sym
+  end
+
+  def remote_browser
+    @remote_browser ||= (ENV['REMOTE_BROWSER'] || :chrome).to_sym
+  end
+
+  def configure
+    set_webdriver
+    start_remote_server if remote? && !ENV["REMOTE_SERVER_URL"]
+    set_browser_args
+    set_guard_proc
+    add_html_routes
+
+    WatirSpec.always_use_server = ie? || safari? || phantomjs? || remote?
+  end
+
+  private
+
+  def start_remote_server
+    require 'selenium/server'
+
+    @server ||= Selenium::Server.new(remote_server_jar,
+                                     port: Selenium::WebDriver::PortProber.above(4444),
+                                     log: !!$DEBUG,
+                                     background: true,
+                                     timeout: 60)
+
+    @server.start
+    at_exit { @server.stop }
+  end
+
+  def remote_server_jar
+    if File.exist?(ENV['REMOTE_SERVER_BINARY'] || '')
+      ENV['REMOTE_SERVER_BINARY']
+    elsif !Dir.glob('selenium-server-standalone*.jar').empty?
+      Dir.glob('selenium-server-standalone*.jar').first
+    else
+      Selenium::Server.download :latest
+    end
+  rescue SocketError
+    # not connected to internet
+    raise Watir::Exception::Error, "unable to find or download selenium-server-standalone jar"
+  end
+
+  def set_webdriver
+    @imp.name          = :webdriver
+    @imp.browser_class = Watir::Browser
+  end
+
+  def set_browser_args
+    args = case browser
+           when :firefox
+             firefox_args
+           when :ff_legacy
+             ff_legacy_args
+           when :chrome
+             chrome_args
+           when :remote
+             remote_args
+           else
+             {desired_capabilities: Selenium::WebDriver::Remote::Capabilities.send(browser)}
+           end
+
+    if ENV['SELECTOR_STATS']
+      listener = SelectorListener.new
+      args.merge!(listener: listener)
+      at_exit { listener.report }
+    end
+
+    @imp.browser_args = [browser, args]
+  end
+
+  def ie?
+    [:internet_explorer].include? browser
+  end
+
+  def safari?
+    browser == :safari
+  end
+
+  def phantomjs?
+    browser == :phantomjs
+  end
+
+  def remote?
+    browser == :remote
+  end
+
+  def set_guard_proc
+    matching_guards = [:webdriver]
+
+    if remote?
+      matching_browser = remote_browser
+      matching_guards << :remote
+      matching_guards << [:remote, matching_browser]
+      matching_guards << [:remote, :ff_legacy] if @ff_legacy
+    else
+      matching_browser = browser
+    end
+
+    matching_guards << :ff_legacy if @ff_legacy
+
+    browser_instance = WatirSpec.new_browser
+    browser_version = browser_instance.driver.capabilities.version
+
+    matching_browser_with_version = "#{browser}#{browser_version}".to_sym
+    matching_guards << matching_browser_with_version if browser_version
+
+    matching_guards << matching_browser
+    matching_guards << [matching_browser, Selenium::WebDriver::Platform.os]
+
+    if !Selenium::WebDriver::Platform.linux? || ENV['DESKTOP_SESSION']
+      # some specs (i.e. Window#maximize) needs a window manager on linux
+      matching_guards << :window_manager
+    end
+
+    @imp.guard_proc = lambda { |args|
+      args.any? { |arg| matching_guards.include?(arg) }
+    }
+  ensure
+    browser_instance.close if browser_instance
+  end
+
+  def firefox_args
+    path = ENV['FIREFOX_BINARY']
+    Selenium::WebDriver::Firefox::Binary.path = path if path
+    {desired_capabilities: Selenium::WebDriver::Remote::Capabilities.firefox}
+  end
+
+  def ff_legacy_args
+    @browser = :firefox
+    @ff_legacy = true
+    caps = Selenium::WebDriver::Remote::Capabilities.firefox(marionette: false)
+    path = ENV['FF_LEGACY_BINARY']
+    Selenium::WebDriver::Firefox::Binary.path = path if path
+    {desired_capabilities: caps}
+  end
+
+  def chrome_args
+    opts = {args: ["--disable-translate"],
+            desired_capabilities: Selenium::WebDriver::Remote::Capabilities.chrome}
+
+    if url = ENV['WATIR_CHROME_SERVER']
+      opts[:url] = url
+    end
+
+    if driver = ENV['WATIR_CHROME_DRIVER']
+      Selenium::WebDriver::Chrome.driver_path = driver
+    end
+
+    if path = ENV['WATIR_CHROME_BINARY']
+      Selenium::WebDriver::Chrome.path = path
+    end
+
+    if ENV['TRAVIS']
+      opts[:args] << "--no-sandbox" # https://github.com/travis-ci/travis-ci/issues/938
+    end
+
+    opts
+  end
+
+  def remote_args
+    url = ENV["REMOTE_SERVER_URL"] || "http://127.0.0.1:#{@server.port}/wd/hub"
+    opts = {}
+    if remote_browser == :ff_legacy
+      path = ENV['FF_LEGACY_BINARY']
+      opts[:firefox_binary] = path if path
+      @remote_browser = :firefox
+      @ff_legacy = true
+      opts[:marionette] = false
+    elsif remote_browser == :firefox
+      path = ENV['FIREFOX_BINARY']
+      opts[:firefox_binary] = path if path
+    end
+
+    caps = Selenium::WebDriver::Remote::Capabilities.send(remote_browser, opts)
+    {url: url, desired_capabilities: caps}
+  end
+
+  def add_html_routes
+    glob = File.expand_path("../html/*.html", __FILE__)
+    Dir[glob].each do |path|
+      WatirSpec::Server.get("/#{File.basename path}") { File.read(path) }
+    end
+  end
+
+  class SelectorListener < Selenium::WebDriver::Support::AbstractEventListener
+    def initialize
+      @counts = Hash.new(0)
+    end
+
+    def before_find(how, what, driver)
+      @counts[how] += 1
+    end
+
+    def report
+      total = @counts.values.inject(0) { |mem, var| mem + var }
+      puts "\nSelenium selector stats: "
+      @counts.each do |how, count|
+        puts "\t#{how.to_s.ljust(20)}: #{count * 100 / total} (#{count})"
+      end
+    end
+
+  end
+end
+
+ImplementationConfig.new(WatirSpec.implementation).configure

data/spec/input_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
+
+describe Watir::Input do
+
+  before do
+    browser.goto WatirSpec.url_for("forms_with_input_elements.html")
+  end
+
+  describe "#type" do
+    it "returns an email type" do
+      expect(browser.input(name: "html5_email").type).to eq 'email'
+    end
+  end
+end

data/spec/locator_spec_helper.rb

@@ -0,0 +1,57 @@
+require 'active_support/ordered_hash'
+
+module LocatorSpecHelper
+  def browser
+    @browser ||= double(Watir::Browser, wd: driver)
+  end
+
+  def driver
+    @driver ||= double(Selenium::WebDriver::Driver)
+  end
+
+  def locator(selector, attrs)
+    attrs ||= Watir::HTMLElement.attributes
+    element_validator = Watir::Locators::Element::Validator.new
+    selector_builder = Watir::Locators::Element::SelectorBuilder.new(driver, selector, attrs)
+    Watir::Locators::Element::Locator.new(browser, selector, selector_builder, element_validator)
+  end
+
+  def expect_one(*args)
+    expect(driver).to receive(:find_element).with(*args)
+  end
+
+  def expect_all(*args)
+    expect(driver).to receive(:find_elements).with(*args)
+  end
+
+  def locate_one(selector, attrs = nil)
+    locator(ordered_hash(selector), attrs).locate
+  end
+
+  def locate_all(selector, attrs = nil)
+    locator(ordered_hash(selector), attrs).locate_all
+  end
+
+  def element(opts = {})
+    attrs = opts.delete(:attributes)
+    el = double(Watir::Element, opts)
+
+    attrs.each do |key, value|
+      allow(el).to receive(:attribute).with(key).and_return(value)
+    end if attrs
+
+    el
+  end
+
+  def ordered_hash(selector)
+    case selector
+    when Hash
+      selector
+    when Array
+      ActiveSupport::OrderedHash[*selector]
+    else
+      raise ArgumentError, "couldn't create hash for #{selector.inspect}"
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'watir'
+require 'locator_spec_helper'
+require 'rubygems'
+require 'rspec'
+
+include Watir
+
+if ENV['ALWAYS_LOCATE'] == "false"
+  Watir.always_locate = false
+end
+
+if ENV['PREFER_CSS']
+  Watir.prefer_css = true
+end
+
+SELENIUM_SELECTORS = %i(class class_name css id tag_name xpath)
+
+if ENV['TRAVIS']
+  ENV['DISPLAY'] = ":99.0"
+
+  if ENV['WATIR_BROWSER'] == "chrome"
+    ENV['WATIR_CHROME_BINARY'] = File.expand_path "chrome-linux/chrome"
+    ENV['WATIR_CHROME_DRIVER'] = File.expand_path "chrome-linux/chromedriver"
+  end
+end
+
+if Selenium::WebDriver::Platform.linux? && ENV['DISPLAY'].nil?
+  raise "DISPLAY not set"
+end