ayanko-watir-webdriver 0.1.1.1

data/lib/watir-webdriver/locators/text_field_locator.rb

@@ -0,0 +1,65 @@
+module Watir
+  class TextFieldLocator < ElementLocator
+
+    NON_TEXT_TYPES     = %w[file radio checkbox submit reset image button hidden url datetime date month week time datetime-local range color]
+    # TODO: better way of finding input text fields?
+    NEGATIVE_TYPE_EXPR = NON_TEXT_TYPES.map { |t| "@type!=#{t.inspect}" }.join(" and ")
+
+    def locate_all
+      find_all_by_multiple
+    end
+
+    private
+
+    def build_xpath(selectors)
+      return if selectors.values.any? { |e| e.kind_of? Regexp }
+
+      selectors.delete(:tag_name)
+
+      @building = :textarea
+      textarea_attr_exp = attribute_expression(selectors)
+
+      @building = :input
+      input_attr_exp = attribute_expression(selectors)
+
+      xpath = ".//input[(not(@type) or (#{NEGATIVE_TYPE_EXPR}))"
+      xpath << " and #{input_attr_exp}" unless input_attr_exp.empty?
+      xpath << "] "
+      xpath << "| .//textarea"
+      xpath << "[#{textarea_attr_exp}]" unless textarea_attr_exp.empty?
+
+      p :build_xpath => xpath if $DEBUG
+
+      xpath
+    end
+
+    def lhs_for(key)
+      if @building == :input && key == :text
+        "@value"
+      elsif @building == :textarea && key == :value
+        "text()"
+      else
+        super
+      end
+    end
+
+    def matches_selector?(element, rx_selector)
+      rx_selector = rx_selector.dup
+
+      [:text, :value, :label].each do |key|
+        if rx_selector.has_key?(key)
+          correct_key = element.tag_name == 'input' ? :value : :text
+          rx_selector[correct_key] = rx_selector.delete(key)
+        end
+      end
+
+      super
+    end
+
+    VALID_TEXT_FIELD_TAGS = %w[input textarea]
+
+    def tag_name_matches?(element, _)
+      VALID_TEXT_FIELD_TAGS.include?(element.tag_name)
+    end
+  end # TextFieldLocator
+end # Watir

data/lib/watir-webdriver/row_container.rb

@@ -0,0 +1,34 @@
+module Watir
+  module RowContainer
+
+    def row(*args)
+      row = tr(*args)
+      row.locator_class = ChildRowLocator
+
+      row
+    end
+
+    def rows(*args)
+      rows = trs(*args)
+      rows.locator_class = ChildRowLocator
+
+      rows
+    end
+    
+    #
+    # The table as a 2D Array of strings with the text of each cell.
+    #
+    # @return [Array<Array<String>>]
+    #
+
+    def strings
+      assert_exists
+
+      rows.inject [] do |res, row|
+        res << row.cells.map { |cell| cell.text }
+      end
+    end
+    alias_method :to_a, :strings
+
+  end
+end

data/lib/watir-webdriver/window_switching.rb

@@ -0,0 +1,105 @@
+module Watir
+  module WindowSwitching
+
+    class NoMatchingWindowFoundException < StandardError
+    end
+
+    def windows(*args)
+      all = @driver.window_handles.map { |id| Window.new(@driver, id) }
+
+      if args.empty?
+        all
+      else
+        filter_windows(args, all, :select)
+      end
+    end
+
+    def window(*args, &blk)
+      win = filter_windows(args, windows, :find)
+
+      if win && block_given?
+        win.use(&blk)
+      end
+
+      win or raise NoMatchingWindowFoundException, args.inspect
+    end
+
+    private
+
+    def filter_windows(args, all, method)
+      sel = extract_selector(args)
+
+      if sel.empty?
+        all.find { |w| w.current? }
+      end
+
+      unless sel.keys.all? { |k| [:title, :url].include? k }
+        raise ArgumentError, "invalid window selector: #{sel.inspect}"
+      end
+
+      all.send(method) do |win|
+        sel.all? { |key, value| value === win.send(key) }
+      end
+    end
+  end # WindowSwitching
+
+  class Window
+    def initialize(driver, id)
+      @driver, @id = driver, id
+    end
+
+    def inspect
+      '#<%s:0x%x id=%s>' % [self.class, hash*2, @id.to_s]
+    end
+
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+
+      @id == other.id
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @id.hash ^ self.class.hash
+    end
+
+    def current?
+      @driver.window_handle == @id
+    end
+
+    def close
+      use { @driver.close }
+    end
+
+    def title
+      title = nil
+      use { title = @driver.title }
+
+      title
+    end
+
+    def url
+      url = nil
+      use { url = @driver.current_url }
+
+      url
+    end
+
+    def use(&blk)
+      if current?
+        yield if block_given?
+        return self
+      end
+
+      @driver.switch_to.window(@id, &blk)
+      self
+    end
+
+    protected
+
+    def id
+      @id
+    end
+
+  end # Window
+end # Watir

data/lib/watir-webdriver/xpath_support.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Watir
+  module XpathSupport
+    include Selenium
+
+    #
+    # Find the first element matching the given XPath
+    #
+
+    def element_by_xpath(xpath)
+      e = wd.find_element(:xpath, xpath)
+      Watir.element_class_for(e.tag_name).new(self, :element => e)
+    rescue WebDriver::Error::NoSuchElementError
+      Element.new(self, :xpath => xpath)
+    end
+
+    #
+    # Find all elements matching the given XPath
+    #
+
+    def elements_by_xpath(xpath)
+      wd.find_elements(:xpath, xpath).map do |e|
+        Watir.element_class_for(e.tag_name).new(self, :element => e)
+      end
+    end
+
+  end # XpathSupport
+end # Watir

data/lib/yard/handlers/watir.rb

@@ -0,0 +1,57 @@
+require "watir-webdriver/core_ext/string"
+
+module YARD
+  module Handlers
+    module Watir
+      #
+      # @private
+      # 
+      
+      class AttributesHandler < YARD::Handlers::Ruby::Base
+        handles method_call(:attributes)
+
+        TYPES = {
+          :string => "String",
+          :bool => "Boolean",
+          :int => "Integer"
+        }
+
+        def process
+          attributes = try_eval
+
+          if attributes.nil?
+            p :ignoring => statement.source, :in => namespace.to_s
+            return
+          end
+
+          TYPES.each do |type, return_type|
+            if attributes.member? type
+              create_attributes attributes[type], return_type
+            end
+          end
+        end
+
+        private
+
+        def create_attributes(names, return_type)
+          names.each do |attribute_name|
+            p :adding => "#{namespace}##{attribute_name}"
+            attribute_name = "#{attribute_name}?".to_sym if return_type == "Boolean"
+            register MethodObject.new(namespace, attribute_name, scope) do |o|
+              o.visibility = :public
+              o.explicit   = false
+              o.docstring.add_tag YARD::Tags::Tag.new(:return, "", return_type)
+            end
+          end
+        end
+
+        def try_eval
+          eval "{#{statement.parameters.source}}"
+        rescue SyntaxError, StandardError
+          nil
+        end
+
+      end # AttributesHandler
+    end # Watir
+  end # Handlers
+end

data/spec/alert_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path("watirspec/spec_helper", File.dirname(__FILE__))
+require "watir-webdriver/extensions/alerts"
+
+describe "AlertHelper" do
+  before do
+    browser.goto("file://" + File.expand_path("html/alerts.html", File.dirname(__FILE__)))
+  end
+
+  it "handles an alert()" do
+    returned = browser.alert do
+      browser.button(:id => "alert").click
+    end
+
+    returned.should == "ok"
+  end
+
+  it "handles a confirmed confirm()" do
+    returned = browser.confirm(true) do
+      browser.button(:id => "confirm").click
+    end
+
+    returned.should == "set the value"
+
+    browser.button(:id => "confirm").value.should == "true"
+  end
+
+  it "handles a cancelled confirm()" do
+    returned = browser.confirm(false) do
+      browser.button(:id => "confirm").click
+    end
+
+    returned.should == "set the value"
+
+    browser.button(:id => "confirm").value.should == "false"
+  end
+
+  it "handles a prompt()" do
+    returned = browser.prompt("my name") do
+      browser.button(:id => "prompt").click
+    end
+
+    returned.should == {
+      :message => "enter your name",
+      :default => "John Doe"
+    }
+
+    browser.button(:id => "prompt").value.should == "my name"
+  end
+end

data/spec/browser_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
+
+describe Watir::Browser do
+
+  describe ".new" do
+    it "passes the args to webdriver" do
+      Selenium::WebDriver.should_receive(:for).with(:firefox, :foo).and_return(nil)
+      Watir::Browser.new(:firefox, :foo)
+    end
+
+    it "takes a Driver instance as argument" do
+      mock_driver = mock(Selenium::WebDriver::Driver)
+      Selenium::WebDriver::Driver.should_receive(:===).with(mock_driver).and_return(true)
+
+      lambda { Watir::Browser.new(mock_driver) }.should_not raise_error
+    end
+
+    it "raises ArgumentError for invalid args" do
+      lambda { Watir::Browser.new(Object.new) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#execute_script" do
+    it "returns DOM elements as Watir objects" do
+      browser.goto(WatirSpec.files + "/definition_lists.html")
+      returned = browser.execute_script("return document.getElementById('experience-list')")
+      returned.should be_kind_of(Watir::DList)
+    end
+  end
+
+  bug "http://github.com/jarib/watirspec/issues/issue/8", [:webdriver, :ie], [:webdriver, :chrome] do
+    it "raises an error when trying to interact with a closed browser" do
+      b = WatirSpec.new_browser
+      b.goto(WatirSpec.files + "/definition_lists.html")
+      b.close
+
+      lambda { b.dl(:id => "experience-list").id }.should raise_error(Error, "browser was closed")
+    end
+  end
+
+
+end

data/spec/container_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
+
+describe Watir::Container do
+  before { @container = Object.new.extend(Watir::Container) }
+
+  describe "#extract_selector" do
+    before do
+      def @container.public_extract_selector(*args)
+        extract_selector(*args)
+      end
+    end
+
+    it "converts 2-arg selector into a hash" do
+      @container.public_extract_selector([:how, 'what']).
+                 should == { :how => 'what' }
+    end
+
+    it "returns the hash given" do
+      @container.public_extract_selector([:how => "what"]).
+                 should == { :how => "what" }
+    end
+
+    it "returns an empty hash if given no args" do
+      @container.public_extract_selector([]).should == {}
+    end
+
+    it "raises ArgumentError if given 1 arg which is not a Hash" do
+      lambda {
+        @container.public_extract_selector([:how])
+      }.should raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if given > 2 args" do
+      lambda {
+        @container.public_extract_selector([:how, 'what', 'value'])
+      }.should raise_error(ArgumentError)
+    end
+
+
+
+  end
+end

data/spec/element_locator_spec.rb

@@ -0,0 +1,304 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe Watir::ElementLocator do
+  include LocatorSpecHelper
+
+  describe "finds a single element" do
+    describe "by delegating to webdriver" do
+      WEBDRIVER_SELECTORS.each do |loc|
+        it "delegates to webdriver's #{loc} locator" do
+          expect_one(loc, "bar").and_return(element(:tag_name => "div"))
+          locate_one loc => "bar"
+        end
+      end
+    end
+
+    describe "with selectors not supported by webdriver" do
+      it "handles selector with tag name and a single attribute" do
+        expect_one :xpath, ".//div[@class='foo']"
+
+        locate_one :tag_name => "div",
+                   :class    => "foo"
+      end
+
+      it "handles selector with no tag name and and a single attribute" do
+        expect_one :xpath, ".//*[@title='foo']"
+        locate_one :title => "foo"
+      end
+
+      it "handles selector with tag name and multiple attributes" do
+        expect_one :xpath, ".//div[@class='foo' and @title='bar']"
+
+        locate_one [:tag_name, "div",
+                    :class   , "foo",
+                    :title   , 'bar']
+      end
+
+      it "handles selector with no tag name and multiple attributes" do
+        expect_one :xpath, ".//*[@class='foo' and @title='bar']"
+
+        locate_one [:class, "foo",
+                    :title, "bar"]
+      end
+    end
+
+
+    describe "with special cased selectors" do
+      it "normalizes space for :text" do
+        expect_one :xpath, ".//div[normalize-space()='foo']"
+        locate_one :tag_name => "div",
+                   :text     => "foo"
+      end
+
+      it "translates :caption to :text" do
+        expect_one :xpath, ".//div[normalize-space()='foo']"
+
+        locate_one :tag_name => "div",
+                   :caption  => "foo"
+      end
+
+      it "translates :class_name to :class" do
+        expect_one :xpath, ".//div[@class='foo']"
+
+        locate_one :tag_name   => "div",
+                   :class_name => "foo"
+      end
+
+      it "handles data-* attributes" do
+        expect_one :xpath, ".//div[@data-name='foo']"
+
+        locate_one :tag_name  => "div",
+                   :data_name => "foo"
+      end
+
+      it "normalizes space for the :href attribute" do
+        expect_one :xpath, ".//a[normalize-space(@href)='foo']"
+
+        selector = {
+          :tag_name => "a",
+          :href     => "foo"
+        }
+
+        locate_one selector, Watir::Anchor.attributes
+      end
+
+      it "uses the corresponding <label>'s @for attribute when locating by label" do
+        expect_one :xpath, ".//input[@type='text' and @id=//label[normalize-space()='foo']/@for]"
+
+        selector = [
+          :tag_name, "input",
+          :type    , "text",
+          :label   , "foo"
+        ]
+
+        locate_one selector, Watir::Input.attributes
+      end
+
+      it "does not use the label element for <option> elements" do
+        expect_one :xpath, ".//option[@label='foo']"
+
+        locate_one :tag_name => "option",
+                   :label    => "foo"
+      end
+
+      it "translates ruby attribute names to content attribute names" do
+        expect_one :xpath, ".//meta[@http-equiv='foo']"
+
+        selector = {
+          :tag_name   => "meta",
+          :http_equiv => "foo"
+        }
+
+        locate_one selector, Watir::Meta.attributes
+
+        # TODO: check edge cases
+      end
+    end
+
+    describe "with regexp selectors" do
+      it "handles selector with tag name and a single regexp attribute" do
+        elements = [
+          element(:tag_name => "div", :attributes => { :class => "foo" }),
+          element(:tag_name => "div", :attributes => { :class => "foob"})
+        ]
+
+        expect_all(:xpath, ".//div").and_return(elements)
+        locate_one(:tag_name => "div", :class => /oob/).should == elements[1]
+      end
+
+      it "handles :tag_name, :index and a single regexp attribute" do
+        elements = [
+          element(:tag_name => "div", :attributes => { :class => "foo" }),
+          element(:tag_name => "div", :attributes => { :class => "foo" })
+        ]
+
+        expect_all(:xpath, ".//div").and_return(elements)
+
+        selector = {
+          :tag_name => "div",
+          :class    => /foo/,
+          :index    => 1
+        }
+
+        locate_one(selector).should == elements[1]
+      end
+
+      it "handles mix of string and regexp attributes" do
+        elements = [
+          element(:tag_name => "div", :attributes => { :class => "foo", :title => "bar" }),
+          element(:tag_name => "div", :attributes => { :class => "foo", :title => "baz" })
+        ]
+
+        expect_all(:xpath, ".//div[@class='foo']").and_return(elements)
+
+        selector = {
+          :tag_name => "div",
+          :class    => "foo",
+          :title    => /baz/
+        }
+
+        locate_one(selector).should == elements[1]
+      end
+
+      it "handles :label => /regexp/ selector" do
+        label_elements = [
+          element(:tag_name => "label", :text => "foo", :attributes => { :for => "bar"}),
+          element(:tag_name => "label", :text => "foob", :attributes => { :for => "baz"})
+        ]
+        div_elements = [element(:tag_name => "div")]
+
+        expect_all(:tag_name, "label").ordered.and_return(label_elements)
+        expect_all(:xpath, ".//div[@id='baz']").ordered.and_return(div_elements)
+
+        locate_one(:tag_name => "div", :label => /oob/).should == div_elements.first
+      end
+
+      it "returns nil when no label matching the regexp is found" do
+        expect_all(:tag_name, "label").and_return([])
+        locate_one(:tag_name => "div", :label => /foo/).should be_nil
+      end
+
+    end
+
+    it "finds all if :index is given" do
+      # or could we use XPath indeces reliably instead?
+      elements = [
+        element(:tag_name => "div"),
+        element(:tag_name => "div")
+      ]
+
+      expect_all(:xpath, ".//div[@class='foo']").and_return(elements)
+
+      selector = {
+        :tag_name => "div",
+        :class    => "foo",
+        :index    => 1
+      }
+
+      locate_one(selector).should == elements[1]
+    end
+
+    it "returns nil if found element didn't match the selector tag_name" do
+      expect_one(:xpath, "//div").and_return(element(:tag_name => "div"))
+
+      selector = {
+        :tag_name => "input",
+        :xpath    => "//div"
+      }
+
+      locate_one(selector, Watir::Input.attributes).should be_nil
+    end
+
+    describe "errors" do
+      it "raises a TypeError if :index is not a Fixnum" do
+        lambda {
+          locate_one(:tag_name => "div", :index => "bar")
+        }.should raise_error(TypeError, %[expected Fixnum, got "bar":String])
+      end
+
+      it "raises a TypeError if selector value is not a String or Regexp" do
+        lambda {
+          locate_one(:tag_name => 123)
+        }.should raise_error(TypeError, %[expected one of [String, Regexp], got 123:Fixnum])
+      end
+
+      it "raises a MissingWayOfFindingObjectException if the attribute is not valid" do
+        bad_selector = {:tag_name => "input", :href => "foo"}
+        valid_attributes = Watir::Input.attributes
+
+        lambda {
+          locate_one(bad_selector, valid_attributes)
+        }.should raise_error(MissingWayOfFindingObjectException, "invalid attribute: :href")
+      end
+    end
+  end
+
+  describe "finds several elements" do
+    describe "by delegating to webdriver" do
+      WEBDRIVER_SELECTORS.each do |loc|
+        it "delegates to webdriver's #{loc} locator" do
+          expect_all(loc, "bar").and_return([element(:tag_name => "div")])
+          locate_all(loc => "bar")
+        end
+      end
+    end
+
+    describe "with selectors not supported by webdriver" do
+      it "handles selector with tag name and a single attribute" do
+        expect_all :xpath, ".//div[@class='foo']"
+
+        locate_all :tag_name => "div",
+                   :class    => "foo"
+      end
+
+      it "handles selector with tag name and multiple attributes" do
+        expect_all :xpath, ".//div[@class='foo' and @title='bar']"
+
+        locate_all [:tag_name, "div",
+                    :class   , "foo",
+                    :title   , 'bar']
+      end
+    end
+
+    describe "with regexp selectors" do
+      it "handles selector with tag name and a single regexp attribute" do
+        elements = [
+          element(:tag_name => "div", :attributes => { :class => "foo" }),
+          element(:tag_name => "div", :attributes => { :class => "foob"}),
+          element(:tag_name => "div", :attributes => { :class => "doob"}),
+          element(:tag_name => "div", :attributes => { :class => "noob"})
+        ]
+
+        expect_all(:xpath, ".//div").and_return(elements)
+        locate_all(:tag_name => "div", :class => /oob/).should == elements.last(3)
+      end
+
+      it "handles mix of string and regexp attributes" do
+        elements = [
+          element(:tag_name => "div", :attributes => { :class => "foo", :title => "bar" }),
+          element(:tag_name => "div", :attributes => { :class => "foo", :title => "baz" }),
+          element(:tag_name => "div", :attributes => { :class => "foo", :title => "bazt"})
+        ]
+
+        expect_all(:xpath, ".//div[@class='foo']").and_return(elements)
+
+        selector = {
+          :tag_name => "div",
+          :class    => "foo",
+          :title    => /baz/
+        }
+
+        locate_all(selector).should == elements.last(2)
+      end
+    end
+
+    describe "errors" do
+      it "raises ArgumentError if :index is given" do
+        lambda {
+          locate_all(:tag_name => "div", :index => 1)
+        }.should raise_error(ArgumentError, "can't locate all elements by :index")
+      end
+    end
+  end
+
+end