watir 5.0.0 → 6.0.0.beta1

data/lib/watir/xpath_support.rb

@@ -0,0 +1,20 @@
+module Watir
+  module XpathSupport
+
+    def self.escape(value)
+      if value.include? "'"
+        parts = value.split("'", -1).map { |part| "'#{part}'" }
+        string = parts.join(%{,"'",})
+
+        "concat(#{string})"
+      else
+        "'#{value}'"
+      end
+    end
+
+    def self.downcase(value)
+      "translate(#{value},'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"
+    end
+
+  end # XpathSupport
+end # Watir

data/spec/always_locate_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
+
+describe 'Watir' do
+  describe '#always_locate?' do
+
+    before do
+      browser.goto WatirSpec.url_for('removed_element.html')
+    end
+
+    it 'determines whether #exist? returns false for stale element' do
+      element = browser.div(id: "text")
+      expect(element.exists?).to be true
+
+      browser.refresh
+
+      expect(element.exists?).to be Watir.always_locate?
+    end
+
+    it 'allows using cached elements regardless of setting, when element is not stale' do
+      element = browser.div(id: "text")
+      expect(element.exists?).to be true
+
+      # exception raised if element is re-looked up
+      allow(browser.driver).to receive(:find_element).with(:id, 'text') { raise }
+
+      expect { element.exists? }.to_not raise_error
+    end
+
+    it 'determines whether an exception is raised when taking an action on a stale element' do
+      element = browser.div(id: "text")
+      expect(element.exists?).to be true
+
+      browser.refresh
+      browser.div(id: "text").wait_until_present
+
+      if Watir.always_locate?
+        expect { element.text }.to_not raise_error
+      else
+        expect { element.text }.to raise_error Watir::Exception::UnknownObjectException
+      end
+    end
+  end
+end

data/spec/browser_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
+
+describe Watir::Browser do
+
+  describe ".new" do
+    it "passes the args to Selenium" do
+      expect(Selenium::WebDriver).to receive(:for).with(:firefox, :foo).and_return(nil)
+      Watir::Browser.new(:firefox, :foo)
+    end
+
+    it "takes a Driver instance as argument" do
+      mock_driver = double(Selenium::WebDriver::Driver)
+      expect(Selenium::WebDriver::Driver).to receive(:===).with(mock_driver).and_return(true)
+      expect { Watir::Browser.new(mock_driver) }.to_not raise_error
+    end
+
+    it "raises ArgumentError for invalid args" do
+      expect { Watir::Browser.new(Object.new) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#execute_script" do
+    before { browser.goto WatirSpec.url_for("definition_lists.html") }
+
+    it "wraps elements as Watir objects" do
+      returned = browser.execute_script("return document.body")
+      expect(returned).to be_kind_of(Watir::Body)
+    end
+
+    it "wraps elements in an array" do
+      list = browser.execute_script("return [document.body];")
+      expect(list.size).to eq 1
+      expect(list.first).to be_kind_of(Watir::Body)
+    end
+
+    it "wraps elements in a Hash" do
+      hash = browser.execute_script("return {element: document.body};")
+      expect(hash['element']).to be_kind_of(Watir::Body)
+    end
+
+    it "wraps elements in a deep object" do
+      hash = browser.execute_script("return {elements: [document.body], body: {element: document.body }}")
+
+      expect(hash['elements'].first).to be_kind_of(Watir::Body)
+      expect(hash['body']['element']).to be_kind_of(Watir::Body)
+    end
+  end
+
+  bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1260233", :firefox do
+    describe "#send_key{,s}" do
+      it "sends keystrokes to the active element" do
+        browser.goto WatirSpec.url_for "forms_with_input_elements.html"
+
+        browser.send_keys "hello"
+        expect(browser.text_field(id: "new_user_first_name").value).to eq "hello"
+      end
+
+      it "sends keys to a frame" do
+        browser.goto WatirSpec.url_for "frames.html"
+        tf = browser.frame.text_field(id: "senderElement")
+        tf.clear
+
+        browser.frame.send_keys "hello"
+
+        expect(tf.value).to eq "hello"
+      end
+    end
+  end
+
+  bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1290814", :firefox do
+    it "raises an error when trying to interact with a closed browser" do
+      b = WatirSpec.new_browser
+      b.goto WatirSpec.url_for "definition_lists.html"
+      b.close
+
+      expect { b.dl(id: "experience-list").id }.to raise_error(Watir::Exception::Error, "browser was closed")
+    end
+  end
+
+  describe "#wait_while" do
+    it "delegates to the Wait module" do
+      expect(Wait).to receive(:while).with(3, "foo").and_yield
+
+      called = false
+      browser.wait_while(3, "foo") { called = true }
+
+      expect(called).to be true
+    end
+  end
+
+  describe "#wait_until" do
+    it "delegates to the Wait module" do
+      expect(Wait).to receive(:until).with(3, "foo").and_yield
+
+      called = false
+      browser.wait_until(3, "foo") { called = true }
+
+      expect(called).to be true
+    end
+  end
+
+  describe "#wait" do
+    it "waits until document.readyState == 'complete'" do
+      expect(browser).to receive(:ready_state).and_return('incomplete')
+      expect(browser).to receive(:ready_state).and_return('complete')
+
+      browser.wait
+    end
+  end
+
+  describe "#ready_state" do
+    it "gets the document's readyState property" do
+      expect(browser).to receive(:execute_script).with('return document.readyState')
+      browser.ready_state
+    end
+  end
+
+  describe "#inspect" do
+    it "works even if browser is closed" do
+      expect(browser).to receive(:url).and_raise(Errno::ECONNREFUSED)
+      expect { browser.inspect }.to_not raise_error
+    end
+  end
+
+  describe '#screenshot' do
+    it 'returns an instance of of Watir::Screenshot' do
+      expect(browser.screenshot).to be_kind_of(Watir::Screenshot)
+    end
+  end
+end

data/spec/click_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../watirspec/spec_helper', __FILE__)
+
+describe Watir::Element do
+  describe "#click" do
+    before {
+      browser.goto WatirSpec.url_for('clicks.html')
+    }
+
+    let(:clicker) { browser.element(id: "click-logger") }
+    let(:log)     { browser.element(id: "log").ps.map { |e| e.text } }
+
+    bug "https://github.com/watir/watir/issues/343", :webdriver do
+      it "clicks an element with text in nested text node using text selector" do
+        browser.element(text: "Can You Click This?").click
+        expect(browser.element(text: "You Clicked It!")).to exist
+      end
+    end
+  end
+end

data/spec/container_spec.rb

@@ -0,0 +1,34 @@
+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
+      expect(@container.public_extract_selector([:how, 'what'])).to eq Hash[how: 'what']
+    end
+
+    it "returns the hash given" do
+      expect(@container.public_extract_selector([how: "what"])).to eq Hash[how: "what"]
+    end
+
+    it "returns an empty hash if given no args" do
+      expect(@container.public_extract_selector([])).to eq Hash[]
+    end
+
+    it "raises ArgumentError if given 1 arg which is not a Hash" do
+      expect {@container.public_extract_selector([:how])}.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if given > 2 args" do
+      expect {@container.public_extract_selector([:how, 'what', 'value'])}.to raise_error(ArgumentError)
+    end
+
+  end
+end

data/spec/element_locator_spec.rb

@@ -0,0 +1,532 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe Watir::Locators::Element::Locator do
+  include LocatorSpecHelper
+
+  describe "finds a single element" do
+    describe "by delegating to Selenium" do
+      SELENIUM_SELECTORS.each do |loc|
+        it "delegates to Selenium'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 Selenium" do
+      it "handles selector with tag name and a single attribute" do
+        if Watir.prefer_css?
+          expect_one :css, 'div[title="foo"]'
+        else
+          expect_one :xpath, ".//div[@title='foo']"
+        end
+
+        locate_one tag_name: "div",
+                   title: "foo"
+      end
+
+      it "handles selector with no tag name and and a single attribute" do
+        if Watir.prefer_css?
+          expect_one :css, '[title="foo"]'
+        else
+          expect_one :xpath, ".//*[@title='foo']"
+        end
+
+        locate_one title: "foo"
+      end
+
+      it "handles single quotes in the attribute string" do
+        if Watir.prefer_css?
+          expect_one :css, %{[title="foo and 'bar'"]}
+        else
+          expect_one :xpath, %{.//*[@title=concat('foo and ',"'",'bar',"'",'')]}
+        end
+
+        locate_one title: "foo and 'bar'"
+      end
+
+      it "handles selector with tag name and multiple attributes" do
+        if Watir.prefer_css?
+          expect_one :css, 'div[title="foo"][dir="bar"]'
+        else
+          expect_one :xpath, ".//div[@title='foo' and @dir='bar']"
+        end
+
+        locate_one [:tag_name, "div",
+                    :title   , "foo",
+                    :dir     , 'bar']
+      end
+
+      it "handles selector with no tag name and multiple attributes" do
+        if Watir.prefer_css?
+          expect_one :css, '[dir="foo"][title="bar"]'
+        else
+          expect_one :xpath, ".//*[@dir='foo' and @title='bar']"
+        end
+
+        locate_one [:dir,   "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
+        if Watir.prefer_css?
+          expect_one :css, "div.foo"
+        else
+          expect_one :xpath, ".//div[contains(concat(' ', @class, ' '), ' foo ')]"
+        end
+
+        locate_one tag_name: "div",
+                   class_name: "foo"
+      end
+
+      it "handles data-* attributes" do
+        if Watir.prefer_css?
+          expect_one :css, 'div[data-name="foo"]'
+        else
+          expect_one :xpath, ".//div[@data-name='foo']"
+        end
+
+        locate_one tag_name: "div",
+                   data_name: "foo"
+      end
+
+      it "handles aria-* attributes" do
+        if Watir.prefer_css?
+          expect_one :css, 'div[aria-label="foo"]'
+        else
+          expect_one :xpath, ".//div[@aria-label='foo']"
+        end
+
+        locate_one tag_name: "div",
+                   aria_label: "foo"
+      end
+
+      it "normalizes space for the :href attribute" do
+        if Watir.prefer_css?
+          expect_one :css, 'a[href~="foo"]'
+        else
+          expect_one :xpath, ".//a[normalize-space(@href)='foo']"
+        end
+
+        selector = {
+          tag_name: "a",
+          href: "foo"
+        }
+
+        locate_one selector, Watir::Anchor.attributes
+      end
+
+      it "wraps :type attribute with translate() for upper case values" do
+        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"
+        expect_one :xpath, ".//input[#{translated_type}='file']"
+
+        selector = [
+          :tag_name, "input",
+          :type    , "file",
+        ]
+
+        locate_one selector, Watir::Input.attributes
+      end
+
+      it "uses the corresponding <label>'s @for attribute or parent::label when locating by label" do
+        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"
+        expect_one :xpath, ".//input[#{translated_type}='text' and (@id=//label[normalize-space()='foo']/@for or parent::label[normalize-space()='foo'])]"
+
+        selector = [
+          :tag_name, "input",
+          :type    , "text",
+          :label   , "foo"
+        ]
+
+        locate_one selector, Watir::Input.attributes
+      end
+
+      it "uses label attribute if it is valid for element" do
+        expect_one :xpath, ".//option[@label='foo']"
+
+        selector = { tag_name: "option", label: "foo" }
+        locate_one selector, Watir::Option.attributes
+      end
+
+      it "translates ruby attribute names to content attribute names" do
+        if Watir.prefer_css?
+          expect_one :css, 'meta[http-equiv="foo"]'
+        else
+          expect_one :xpath, ".//meta[@http-equiv='foo']"
+        end
+
+        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"})
+        ]
+
+        if Watir.prefer_css?
+          expect_all(:css, "div").and_return(elements)
+        else
+          expect_all(:xpath, "(.//div)[contains(@class, 'oob')]").and_return(elements)
+        end
+
+        expect(locate_one(tag_name: "div", class: /oob/)).to eq 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" })
+        ]
+
+        if Watir.prefer_css?
+          expect_all(:css, "div").and_return(elements)
+        else
+          expect_all(:xpath, "(.//div)[contains(@class, 'foo')]").and_return(elements)
+        end
+
+        selector = {
+          tag_name: "div",
+          class: /foo/,
+          index: 1
+        }
+
+        expect(locate_one(selector)).to eq elements[1]
+      end
+
+      it "handles :xpath and :index selectors" do
+        elements = [
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foo" })
+        ]
+
+        expect_all(:xpath, './/div[@class="foo"]').and_return(elements)
+
+        selector = {
+          xpath: './/div[@class="foo"]',
+          index: 1
+        }
+
+        expect(locate_one(selector)).to eq elements[1]
+      end
+
+      it "handles :css and :index selectors" do
+        elements = [
+          element(tag_name: "div", attributes: { class: "foo" }),
+          element(tag_name: "div", attributes: { class: "foo" })
+        ]
+
+        expect_all(:css, 'div[class="foo"]').and_return(elements)
+
+        selector = {
+          css: 'div[class="foo"]',
+          index: 1
+        }
+
+        expect(locate_one(selector)).to eq elements[1]
+      end
+
+      it "handles mix of string and regexp attributes" do
+        elements = [
+          element(tag_name: "div", attributes: { dir: "foo", title: "bar" }),
+          element(tag_name: "div", attributes: { dir: "foo", title: "baz" })
+        ]
+
+        if Watir.prefer_css?
+          expect_all(:css, 'div[dir="foo"]').and_return(elements)
+        else
+          expect_all(:xpath, "(.//div[@dir='foo'])[contains(@title, 'baz')]").and_return(elements)
+        end
+
+        selector = {
+          tag_name: "div",
+          dir: "foo",
+          title: /baz/
+        }
+
+        expect(locate_one(selector)).to eq elements[1]
+      end
+
+      it "handles data-* attributes with regexp" do
+        elements = [
+          element(tag_name: "div", attributes: { :'data-automation-id' => "foo" }),
+          element(tag_name: "div", attributes: { :'data-automation-id' => "bar" })
+        ]
+
+        if Watir.prefer_css?
+          expect_all(:css, 'div').and_return(elements)
+        else
+          expect_all(:xpath, "(.//div)[contains(@data-automation-id, 'bar')]").and_return(elements)
+        end
+
+
+        selector = {
+          tag_name: "div",
+          data_automation_id: /bar/
+        }
+
+        expect(locate_one(selector)).to eq 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)
+
+        if Watir.prefer_css?
+          expect_all(:css, 'div[id="baz"]').ordered.and_return(div_elements)
+        else
+          expect_all(:xpath, ".//div[@id='baz']").ordered.and_return(div_elements)
+        end
+
+        expect(locate_one(tag_name: "div", label: /oob/)).to eq div_elements.first
+      end
+
+      it "returns nil when no label matching the regexp is found" do
+        expect_all(:tag_name, "label").and_return([])
+        expect(locate_one(tag_name: "div", label: /foo/)).to 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")
+      ]
+
+      if Watir.prefer_css?
+        expect_all(:css, 'div[dir="foo"]').and_return(elements)
+      else
+        expect_all(:xpath, ".//div[@dir='foo']").and_return(elements)
+      end
+
+      selector = {
+        tag_name: "div",
+        dir: "foo",
+        index: 1
+      }
+
+      expect(locate_one(selector)).to eq 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"
+      }
+
+      expect(locate_one(selector, Watir::Input.attributes)).to be_nil
+    end
+
+    describe "errors" do
+      it "raises a TypeError if :index is not a Fixnum" do
+        expect { locate_one(tag_name: "div", index: "bar") }.to \
+        raise_error(TypeError, %[expected Fixnum, got "bar":String])
+      end
+
+      it "raises a TypeError if selector value is not a String or Regexp" do
+        expect { locate_one(tag_name: 123) }.to \
+        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
+
+        expect { locate_one(bad_selector, valid_attributes) }.to \
+        raise_error(Watir::Exception::MissingWayOfFindingObjectException, "invalid attribute: :href")
+      end
+    end
+  end
+
+  describe "finds several elements" do
+    describe "by delegating to Selenium" do
+      SELENIUM_SELECTORS.each do |loc|
+        it "delegates to Selenium's #{loc} locator" do
+          expect_all(loc, "bar").and_return([element(tag_name: "div")])
+          locate_all(loc => "bar")
+        end
+      end
+    end
+
+    describe "with an empty selector" do
+      it "finds all when an empty selctor is given" do
+        if Watir.prefer_css?
+          expect_all :css, '*'
+        else
+          expect_all :xpath, './/*'
+        end
+
+        locate_all({})
+      end
+    end
+
+    describe "with selectors not supported by Selenium" do
+      it "handles selector with tag name and a single attribute" do
+        if Watir.prefer_css?
+          expect_all :css, 'div[dir="foo"]'
+        else
+          expect_all :xpath, ".//div[@dir='foo']"
+        end
+
+        locate_all tag_name: "div",
+                   dir: "foo"
+      end
+
+      it "handles selector with tag name and multiple attributes" do
+        if Watir.prefer_css?
+          expect_all :css, 'div[dir="foo"][title="bar"]'
+        else
+          expect_all :xpath, ".//div[@dir='foo' and @title='bar']"
+        end
+
+        locate_all [:tag_name, "div",
+                    :dir     , "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"})
+        ]
+
+        if Watir.prefer_css?
+          expect_all(:css, "div").and_return(elements)
+        else
+          expect_all(:xpath, "(.//div)[contains(@class, 'oob')]").and_return(elements)
+        end
+
+        expect(locate_all(tag_name: "div", class: /oob/)).to eq elements.last(3)
+      end
+
+      it "handles mix of string and regexp attributes" do
+        elements = [
+          element(tag_name: "div", attributes: { dir: "foo", title: "bar" }),
+          element(tag_name: "div", attributes: { dir: "foo", title: "baz" }),
+          element(tag_name: "div", attributes: { dir: "foo", title: "bazt"})
+        ]
+
+        if Watir.prefer_css?
+          expect_all(:css, 'div[dir="foo"]').and_return(elements)
+        else
+          expect_all(:xpath, "(.//div[@dir='foo'])[contains(@title, 'baz')]").and_return(elements)
+        end
+
+        selector = {
+          tag_name: "div",
+          dir: "foo",
+          title: /baz/
+        }
+
+        expect(locate_all(selector)).to eq elements.last(2)
+      end
+
+      context "and xpath" do
+        before do
+          expect(Watir).to receive(:prefer_css?).and_return(false)
+        end
+
+        it "converts a leading run of regexp literals to a contains() expression" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob" }),
+            element(tag_name: "div", attributes: { class: "bar" })
+          ]
+
+          expect_all(:xpath, "(.//div)[contains(@class, 'fo')]").and_return(elements.first(2))
+
+          expect(locate_one(tag_name: "div", class: /fo.b$/)).to eq elements[1]
+        end
+
+        it "converts a trailing run of regexp literals to a contains() expression" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob" })
+          ]
+
+          expect_all(:xpath, "(.//div)[contains(@class, 'b')]").and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /^fo.b/)).to eq elements[1]
+        end
+
+        it "converts a leading and a trailing run of regexp literals to a contains() expression" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob" })
+          ]
+
+          expect_all(:xpath, "(.//div)[contains(@class, 'fo') and contains(@class, 'b')]").
+            and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /fo.b/)).to eq elements[1]
+        end
+
+        it "does not try to convert case insensitive expressions" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob"})
+          ]
+
+          expect_all(:xpath, ".//div").and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /FOOB/i)).to eq elements[1]
+        end
+
+        it "does not try to convert expressions containing '|'" do
+          elements = [
+            element(tag_name: "div", attributes: { class: "foo" }),
+            element(tag_name: "div", attributes: { class: "foob"})
+          ]
+
+          expect_all(:xpath, ".//div").and_return(elements.last(1))
+
+          expect(locate_one(tag_name: "div", class: /x|b/)).to eq elements[1]
+        end
+      end
+    end
+
+    describe "errors" do
+      it "raises ArgumentError if :index is given" do
+        expect { locate_all(tag_name: "div", index: 1) }.to \
+        raise_error(ArgumentError, "can't locate all elements by :index")
+      end
+    end
+  end
+
+end