druid-ts 1.1.3 → 1.1.4

data/lib/druid/javascript_framework_facade.rb

@@ -1,5 +1,6 @@
 require 'druid/javascript/jquery'
 require 'druid/javascript/prototype'
+require 'druid/javascript/yui'
 
 module Druid
   #
@@ -56,7 +57,8 @@ module Druid
       def initialize_script_builder
         @builder = {
           :jquery => Druid::Javascript::JQuery,
-          :prototype => Druid::Javascript::Prototype
+          :prototype => Druid::Javascript::Prototype,
+          :yui => Druid::Javascript::YUI
         }
       end
 

data/lib/druid/nested_elements.rb

@@ -53,7 +53,7 @@ module Druid
     end
 
     def checkbox_elements(identifier={:index => 0})
-      checkboxs_for(identifier)
+      checkboxes_for(identifier)
     end
 
     def radio_button_element(identifier={:index => 0})

data/lib/druid/page_factory.rb

@@ -61,6 +61,31 @@ module Druid
     # Support 'on' for readability of usage
     alias_method :on, :on_page
 
+    #
+    # Create a page object if and only if the current page is the same page to be created
+    #
+    # @example
+    #  original:
+    #   on_page(NewProduct).save if @current_page.class == NewProduct
+    #   on_page(EditProduct).save if @current_page.class == EditProduct
+    #  new:
+    #   if_page NewProduct do |page|
+    #      page.save
+    #   end
+    #   if_page EditProduct do |page|
+    #      page.update 
+    #   end
+    # @param [PageObject] a class that has included the Druid module
+    # @param [block] an optional block to be called
+    # @return [PageObject] the newly created page object
+    def if_page(page_class, &block)
+      return @current_page unless @current_page.class == page_class
+      on_page(page_class, false, &block)
+    end
+
+    # support 'if' for readability of usage
+    alias_method :if, :if_page
+
     #
     # Navigate to a specific page following a predefined path.
     #

data/lib/druid/page_populator.rb

@@ -65,6 +65,7 @@ module Druid
     end
 
     def is_enabled?(key)
+      return true if (self.send "#{key}_element").tag_name == "textarea"
       self.send("#{key}_element").enabled?
     end
   end

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module Druid
-  VERSION = "1.1.3"
+  VERSION = "1.1.4"
 end

data/spec/druid/accessors_spec.rb

@@ -158,6 +158,15 @@ describe Druid::Accessors do
       expect(druid).to have_expected_title
     end
 
+    it "should validate the by regexp" do
+      class RegexpExpectedTitle
+        include Druid
+        expected_title /\w+ \w+/
+      end
+      expect(driver).to receive(:title).and_return("Expected Title")
+      expect(RegexpExpectedTitle.new(driver)).to have_expected_title
+    end
+
     it "should raise error when it does not have expected title" do
       expect(driver).to receive(:title).twice.and_return("Not Expected")
       expect {druid.has_expected_title? }.to raise_error
@@ -180,6 +189,184 @@ describe Druid::Accessors do
     end
   end
 
+  describe "using default identifiers" do
+    class DefaultIdentifier
+      include Druid
+      text_field(:default_tf)
+      hidden_field(:default_hf)
+      text_area(:default_ta)
+      select_list(:default_sl)
+      link(:default_link)
+      checkbox(:default_cb)
+      radio_button(:default_rb)
+      button(:default_but)
+      div(:default_div)
+      span(:default_span)
+      table(:default_tab)
+      cell(:default_cell)
+      image(:default_im)
+      form(:default_form)
+      list_item(:default_li)
+      unordered_list(:default_ul)
+      ordered_list(:default_ol)
+      h1(:default_h1)
+      h2(:default_h2)
+      h3(:default_h3)
+      h4(:default_h4)
+      h5(:default_h5)
+      h6(:default_h6)
+      paragraph(:default_p)
+      file_field(:default_ff)
+      label(:default_lab)
+      element(:default_el, :audio)
+    end
+
+    let(:default_identifier) { DefaultIdentifier.new(driver) }
+
+    before(:each) do
+      expect(driver).to receive(:exist?).and_return(true)
+    end
+
+    def mock_driver_for(tag)
+      expect(driver).to receive(tag).with(:index => 0).and_return(driver)
+    end
+
+    it "should work with a text_field" do
+      mock_driver_for :text_field
+      default_identifier.default_tf?
+    end
+
+    it "should work with a hidden field" do
+      mock_driver_for :hidden
+      default_identifier.default_hf?
+    end
+
+    it "should work with a text area" do
+      mock_driver_for :textarea
+      default_identifier.default_ta?
+    end
+
+    it "should work with a select list" do
+      mock_driver_for :select_list
+      default_identifier.default_sl?
+    end
+
+    it "should work with a link" do
+      mock_driver_for :link
+      default_identifier.default_link?
+    end
+
+    it "should work with a checkbox" do
+      mock_driver_for :checkbox
+      default_identifier.default_cb?
+    end
+
+    it "should work with a radio button" do
+      mock_driver_for :radio
+      default_identifier.default_rb?
+    end
+
+    it "should work with a button" do
+      mock_driver_for :button
+      default_identifier.default_but?
+    end
+
+    it "should work with a div" do
+      mock_driver_for :div
+      default_identifier.default_div?
+    end
+
+    it "should work with a span" do
+      mock_driver_for :span
+      default_identifier.default_span?
+    end
+
+    it "should work with a table" do
+      mock_driver_for :table
+      default_identifier.default_tab?
+    end
+
+    it "should work with a cell" do
+      mock_driver_for :td
+      default_identifier.default_cell?
+    end
+
+    it "should work with an image" do
+      mock_driver_for :image
+      default_identifier.default_im?
+    end
+
+    it "should work with a form" do
+      mock_driver_for :form
+      default_identifier.default_form?
+    end
+
+    it "should work with a list item" do
+      mock_driver_for :li
+      default_identifier.default_li?
+    end
+
+    it "should work with unordered lists" do
+      mock_driver_for :ul
+      default_identifier.default_ul?
+    end
+
+    it "should work with ordered lists" do
+      mock_driver_for :ol
+      default_identifier.default_ol?
+    end
+
+    it "should work with h1" do
+      mock_driver_for :h1
+      default_identifier.default_h1?
+    end
+
+    it "should work with h2" do
+      mock_driver_for :h2
+      default_identifier.default_h2?
+    end
+
+    it "should work with h3" do
+      mock_driver_for :h3
+      default_identifier.default_h3?
+    end
+
+    it "should work with h4" do
+      mock_driver_for :h4
+      default_identifier.default_h4?
+    end
+
+    it "should work with h5" do
+      mock_driver_for :h5
+      default_identifier.default_h5?
+    end
+
+    it "should work with h6" do
+      mock_driver_for :h6
+      default_identifier.default_h6?
+    end
+
+    it "should work with paragraph" do
+      mock_driver_for :p
+      default_identifier.default_p?
+    end
+
+    it "should work with file_field" do
+      mock_driver_for :file_field
+      default_identifier.default_ff?
+    end
+
+    it "should work with a label" do
+      mock_driver_for :label
+      default_identifier.default_lab?
+    end
+
+    it "should work with an element" do
+      mock_driver_for :audio
+      default_identifier.default_el?
+    end
+  end
+
   describe "check_box accessors" do
     context "when called on a page object" do
       it "should generate accessor methods" do
@@ -285,6 +472,7 @@ describe Druid::Accessors do
         expect(druid).to respond_to(:first_name)
         expect(druid).to respond_to(:first_name=)
         expect(druid).to respond_to(:first_name_element)
+        expect(druid).to respond_to(:first_name?)
       end
 
       it "should call a block on the element method when present" do
@@ -544,7 +732,7 @@ describe Druid::Accessors do
 
     context "implementation" do
       it "should set some text on the text area" do
-        expect(driver).to receive_message_chain(:textarea, :send_keys).with('123 main street')
+        expect(driver).to receive_message_chain(:textarea, :set).with('123 main street')
         druid.address='123 main street'
       end
 

data/spec/druid/druid_spec.rb

@@ -154,6 +154,12 @@ describe Druid do
         druid.save_screenshot('tim.png')
       end
 
+      it "should use the overriden timeout value when set" do
+        Druid.default_page_wait = 10
+        expect(driver).to receive(:wait_until).with(10, nil)
+        druid.wait_until
+      end
+
       it "should wait until there are no pending ajax requests" do
         expect(Druid::JavascriptFrameworkFacade).to receive(:pending_requests).and_return('pending requests')
         expect(driver).to receive(:execute_script).with('pending requests').and_return(0)

data/spec/druid/element_locators_spec.rb

@@ -14,96 +14,177 @@ describe Druid::ElementLocators do
     expect(button).to be_instance_of Druid::Elements::Button
   end
 
+  it "should find a button element using a default identifier" do
+    expect(driver).to receive(:button).with(:index => 0).and_return(driver)
+    page.button_element
+  end
+
   it "should find all button elements" do
     expect(driver).to receive(:buttons).with(:id => 'blah').and_return([driver])
     elements = page.button_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Button
   end
 
+  it "should find all buttons with no identifier" do
+    expect(driver).to receive(:buttons).with({}).and_return([driver])
+    page.button_elements
+  end
+
   it "should find a text field element" do
     expect(driver).to receive(:text_field).with(:id => 'blah').and_return(driver)
     text_field = page.text_field_element(:id => 'blah')
     expect(text_field).to be_instance_of Druid::Elements::TextField
   end
 
+  it "should find a text field element using a default identifier" do
+    expect(driver).to receive(:text_field).with(:index => 0).and_return(driver)
+    page.text_field_element
+  end
+
   it "should find all text field elemnts" do
     expect(driver).to receive(:text_fields).with(:id => 'blah').and_return([driver])
+    expect(driver).to receive(:tag_name).and_return('input')
     elements = page.text_field_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::TextField
   end
 
+  it "should find all text fields with no identifier" do
+    expect(driver).to receive(:text_fields).with({}).and_return([driver])
+    expect(driver).to receive(:tag_name).and_return('input')
+    page.text_field_elements
+  end
+
   it "should find a hidden field element" do
     expect(driver).to receive(:hidden).with(:id => 'blah').and_return(driver)
     element = page.hidden_field_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::HiddenField
   end
 
+  it "should find a hidden field element using a default identifier" do
+    expect(driver).to receive(:hidden).with(:index => 0).and_return(driver)
+    page.hidden_field_element
+  end
+
   it "should find all hidden field elements" do
     expect(driver).to receive(:hiddens).with(:id => 'blah').and_return([driver])
     elements = page.hidden_field_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::HiddenField
   end
 
+  it "should find all hidden fields using no identifier" do
+    expect(driver).to receive(:hiddens).with({}).and_return([driver])
+    page.hidden_field_elements
+  end
+
   it "should find a text area element" do
     expect(driver).to receive(:textarea).with(:id => 'blah').and_return(driver)
     element = page.text_area_element(:id => "blah")
     expect(element).to be_instance_of Druid::Elements::TextArea
   end
 
+  it "should find a text area element using a default identifier" do
+    expect(driver).to receive(:textarea).with(:index => 0).and_return(driver)
+    page.text_area_element
+  end
+
   it "should find all text area elements" do
     expect(driver).to receive(:textareas).with(:id => 'blah').and_return([driver])
     elements = page.text_area_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::TextArea
   end
 
+  it "should find all text areas using no identifier" do
+    expect(driver).to receive(:textareas).with({}).and_return([driver])
+    page.text_area_elements
+  end
+
   it "should find a select list element" do
     expect(driver).to receive(:select_list).with(:id => 'blah').and_return(driver)
     element = page.select_list_element(:id => "blah")
     expect(element).to be_instance_of Druid::Elements::SelectList
   end
 
+  it "should find a select list element using a default identifier" do
+    expect(driver).to receive(:select_list).with(:index => 0).and_return(driver)
+    page.select_list_element
+  end
+
   it "should find all select list elements" do
     expect(driver).to receive(:select_lists).with(:id => 'blah').and_return([driver])
     elements = page.select_list_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::SelectList
   end
 
+  it "should find all select lists using no identifier" do
+    expect(driver).to receive(:select_lists).with({}).and_return([driver])
+    page.select_list_elements
+  end
+
   it "should find a link element" do
     expect(driver).to receive(:link).with(:id => 'blah').and_return(driver)
     element = page.link_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Link
   end
 
+  it "should find a link element using a default identifier" do
+    expect(driver).to receive(:link).with(:index => 0).and_return(driver)
+    page.link_element
+  end
+
   it "should find all link elements" do
     expect(driver).to receive(:links).with(:id => 'blah').and_return([driver])
     elements = page.link_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Link
   end
 
+  it "should find all links using no identifier" do
+    expect(driver).to receive(:links).with({}).and_return([driver])
+    page.link_elements
+  end
+
   it "should find a check box element" do
     expect(driver).to receive(:checkbox).with(:id => 'blah').and_return(driver)
     element = page.checkbox_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::CheckBox
   end
 
+  it "should find a check box element using a default identifier" do
+    expect(driver).to receive(:checkbox).with(:index => 0).and_return(driver)
+    page.checkbox_element
+  end
+
   it "should find all check box elements" do
     expect(driver).to receive(:checkboxes).with(:id => 'blah').and_return([driver])
     elements = page.checkbox_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::CheckBox
   end
 
+  it "should find all checkboxes using no identifier" do
+    expect(driver).to receive(:checkboxes).with({}).and_return([driver])
+    page.checkbox_elements
+  end
+
   it "should find a radio button element" do
     expect(driver).to receive(:radio).with(:id => 'blah').and_return(driver)
     element = page.radio_button_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::RadioButton
   end
 
+  it "should find a radio button element using a default identifier" do
+    expect(driver).to receive(:radio).with(:index => 0).and_return(driver)
+    page.radio_button_element
+  end
+
   it "should find all radio button elements" do
     expect(driver).to receive(:radios).with(:id => 'blah').and_return([driver])
     elements = page.radio_button_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::RadioButton
   end
 
+  it "should find all radio buttons using no identifier" do
+    expect(driver).to receive(:radios).with({}).and_return([driver])
+    page.radio_button_elements
+  end
 
   it "should find a div element" do
     expect(driver).to receive(:div).with(:id => 'blah').and_return(driver)
@@ -111,96 +192,175 @@ describe Druid::ElementLocators do
     expect(element).to be_instance_of Druid::Elements::Div
   end
 
+  it "should find a div element using a default identifier" do
+    expect(driver).to receive(:div).with(:index => 0).and_return(driver)
+    page.div_element
+  end
+
   it "should find all div elements" do
     expect(driver).to receive(:divs).with(:id => 'blah').and_return([driver])
     elements = page.div_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Div
   end
 
+  it "should find all divs using no identifier" do
+    expect(driver).to receive(:divs).with({}).and_return([driver])
+    page.div_elements
+  end
+
   it "should find a span element" do
     expect(driver).to receive(:span).with(:id => 'blah').and_return(driver)
     element = page.span_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Span
   end
 
+  it "should find a span element using a default identifier" do
+    expect(driver).to receive(:span).with(:index => 0).and_return(driver)
+    page.span_element
+  end
+
   it "should find all span elements" do
     expect(driver).to receive(:spans).with(:id => 'blah').and_return([driver])
     elements = page.span_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Span
   end
 
+  it "should find all spans using no identifier" do
+    expect(driver).to receive(:spans).with({}).and_return([driver])
+    page.span_elements
+  end
+
   it "should find a table element" do
     expect(driver).to receive(:table).with(:id => 'blah').and_return(driver)
     element = page.table_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Table
   end
 
+  it "should find a table element using a default identifier" do
+    expect(driver).to receive(:table).with(:index => 0).and_return(driver)
+    page.table_element
+  end
+
   it "should find all table elements" do
     expect(driver).to receive(:tables).with(:id => 'blah').and_return([driver])
     elements = page.table_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Table
   end
 
+  it "should find all tables using no identifier" do
+    expect(driver).to receive(:tables).with({}).and_return([driver])
+    page.table_elements
+  end
+
   it "should find a table cell element" do
     expect(driver).to receive(:td).with(:id => 'blah').and_return(driver)
     element = page.cell_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::TableCell
   end
 
+  it "should find a table cell element using a default identifier" do
+    expect(driver).to receive(:td).with(:index => 0).and_return(driver)
+    page.cell_element
+  end
+
   it "should find all table cells" do
     expect(driver).to receive(:tds).with(:id => 'blah').and_return([driver])
     elements = page.cell_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::TableCell
   end
 
+  it "should find all table cells using no identifier" do
+    expect(driver).to receive(:tds).with({}).and_return([driver])
+    page.cell_elements
+  end
+
   it "should find an image element" do
     expect(driver).to receive(:image).with(:id => 'blah').and_return(driver)
     element = page.image_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Image
   end
 
+  it "should find a image element using a default identifier" do
+    expect(driver).to receive(:image).with(:index => 0).and_return(driver)
+    page.image_element
+  end
+
   it "should find all image elements" do
     expect(driver).to receive(:images).with(:id => 'blah').and_return([driver])
     elements = page.image_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Image
   end
 
+  it "should find all images using no identifier" do
+    expect(driver).to receive(:images).with({}).and_return([driver])
+    page.image_elements
+  end
+
   it "should find a form element" do
     expect(driver).to receive(:form).with(:id => 'blah').and_return(driver)
     element = page.form_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Form
   end
 
+  it "should find a form element using a default identifier" do
+    expect(driver).to receive(:form).with(:index => 0).and_return(driver)
+    page.form_element
+  end
+
   it "should find all form elements" do
     expect(driver).to receive(:forms).with(:id => 'blah').and_return([driver])
     elements = page.form_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Form
   end
 
+  it "should find all forms using no identifier" do
+    expect(driver).to receive(:forms).with({}).and_return([driver])
+    page.form_elements
+  end
+
   it "should find a list item element" do
     expect(driver).to receive(:li).with(:id => 'blah').and_return(driver)
     element = page.list_item_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::ListItem
   end
 
+  it "should find a list item element using a default identifier" do
+    expect(driver).to receive(:li).with(:index => 0).and_return(driver)
+    page.list_item_element
+  end
+
   it "should find all list item elements" do
     expect(driver).to receive(:lis).with(:id => 'blah').and_return([driver])
     elements = page.list_item_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::ListItem
   end
 
+  it "should find all list items using no identifier" do
+    expect(driver).to receive(:lis).with({}).and_return([driver])
+    page.list_item_elements
+  end
+
   it "should find an ordered list element" do
     expect(driver).to receive(:ol).with(:id => 'blah').and_return(driver)
     element = page.ordered_list_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::OrderedList
   end
 
+  it "should find an ordered list element using a default identifier" do
+    expect(driver).to receive(:ol).with(:index => 0).and_return(driver)
+    page.ordered_list_element
+  end
+
   it "should find all ordered list elements" do
     expect(driver).to receive(:ols).with(:id => 'blah').and_return([driver])
     elements = page.ordered_list_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::OrderedList
   end
 
+  it "should find all ordered lists using no identifier" do
+    expect(driver).to receive(:ols).with({}).and_return([driver])
+    page.ordered_list_elements
+  end
 
   it "should find an unordered list element" do
     expect(driver).to receive(:ul).with(:id => 'blah').and_return(driver)
@@ -208,12 +368,21 @@ describe Druid::ElementLocators do
     expect(element).to be_instance_of Druid::Elements::UnOrderedList
   end
 
+  it "should find an unordered list element using a default identifier" do
+    expect(driver).to receive(:ul).with(:index => 0).and_return(driver)
+    page.unordered_list_element
+  end
+
   it "should find all unordered list elements" do
     expect(driver).to receive(:uls).with(:id => 'blah').and_return([driver])
     elements = page.unordered_list_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::UnOrderedList
   end
 
+  it "should find all unordered lists using no identifier" do
+    expect(driver).to receive(:uls).with({}).and_return([driver])
+    page.unordered_list_elements
+  end
 
   it "should find a h1 element" do
     expect(driver).to receive(:h1).with(:id => 'blah').and_return(driver)
@@ -221,72 +390,132 @@ describe Druid::ElementLocators do
     expect(element).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find a h1 element using a default identifier" do
+    expect(driver).to receive(:h1).with(:index => 0).and_return(driver)
+    page.h1_element
+  end
+
   it "should find all h1 elements" do
     expect(driver).to receive(:h1s).with(:id => 'blah').and_return([driver])
     elements = page.h1_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find all h1s using no identifier" do
+    expect(driver).to receive(:h1s).with({}).and_return([driver])
+    page.h1_elements
+  end
+
   it "should find a h2 element" do
     expect(driver).to receive(:h2).with(:id => 'blah').and_return(driver)
     element = page.h2_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find a h2 element using a default identifier" do
+    expect(driver).to receive(:h2).with(:index => 0).and_return(driver)
+    page.h2_element
+  end
+
   it "should find all h2 elements" do
     expect(driver).to receive(:h2s).with(:id => 'blah').and_return([driver])
     elements = page.h2_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find all h2s using no identifier" do
+    expect(driver).to receive(:h2s).with({}).and_return([driver])
+    page.h2_elements
+  end
+
   it "should find a h3 element" do
     expect(driver).to receive(:h3).with(:id => 'blah').and_return(driver)
     element = page.h3_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find a h3 element using a default identifier" do
+    expect(driver).to receive(:h3).with(:index => 0).and_return(driver)
+    page.h3_element
+  end
+
   it "should find all h3 elements" do
     expect(driver).to receive(:h3s).with(:id => 'blah').and_return([driver])
     elements = page.h3_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find all h3s using no identifier" do
+    expect(driver).to receive(:h3s).with({}).and_return([driver])
+    page.h3_elements
+  end
+
   it "should find a h4 element" do
     expect(driver).to receive(:h4).with(:id => 'blah').and_return(driver)
     element = page.h4_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find a h4 element using a default identifier" do
+    expect(driver).to receive(:h4).with(:index => 0).and_return(driver)
+    page.h4_element
+  end
+
   it "should find all h4 elements" do
     expect(driver).to receive(:h4s).with(:id => 'blah').and_return([driver])
     elements = page.h4_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find all h4s using no identifier" do
+    expect(driver).to receive(:h4s).with({}).and_return([driver])
+    page.h4_elements
+  end
+
   it "should find a h5 element" do
     expect(driver).to receive(:h5).with(:id => 'blah').and_return(driver)
     element = page.h5_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find a h5 element using a default identifier" do
+    expect(driver).to receive(:h5).with(:index => 0).and_return(driver)
+    page.h5_element
+  end
+
   it "should find all h5 elements" do
     expect(driver).to receive(:h5s).with(:id => 'blah').and_return([driver])
     elements = page.h5_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find all h5s using no identifier" do
+    expect(driver).to receive(:h5s).with({}).and_return([driver])
+    page.h5_elements
+  end
+
   it "should find a h6 element" do
     expect(driver).to receive(:h6).with(:id => 'blah').and_return(driver)
     element = page.h6_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find a h6 element using a default identifier" do
+    expect(driver).to receive(:h6).with(:index => 0).and_return(driver)
+    page.h6_element
+  end
+
   it "should find all h6 elements" do
     expect(driver).to receive(:h6s).with(:id => 'blah').and_return([driver])
     elements = page.h6_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Heading
   end
 
+  it "should find all h6s using no identifier" do
+    expect(driver).to receive(:h6s).with({}).and_return([driver])
+    page.h6_elements
+  end
+
   it "should find a paragraph element" do
     expect(driver).to receive(:p).with(:id => 'blah').and_return(driver)
     element = page.paragraph_element(:id => 'blah')
@@ -299,21 +528,68 @@ describe Druid::ElementLocators do
     expect(elements[0]).to be_instance_of Druid::Elements::Paragraph
   end
 
+  it "should find a paragraph element using a default identifier" do
+    expect(driver).to receive(:p).with(:index => 0).and_return(driver)
+    page.paragraph_element
+  end
+
+  it "should find all paragraphs using no identifier" do
+    expect(driver).to receive(:ps).with({}).and_return([driver])
+    page.paragraph_elements
+  end
+
   it "should find a file field element" do
     expect(driver).to receive(:file_field).with(:id => 'blah').and_return(driver)
     element = page.file_field_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::FileField
   end
 
+  it "should find a file field element using a default identifier" do
+    expect(driver).to receive(:file_field).with(:index => 0).and_return(driver)
+    page.file_field_element
+  end
+
+  it "should find all file field elements" do
+    expect(driver).to receive(:file_fields).with(:id => 'blah').and_return([driver])
+    element = page.file_field_elements(:id => 'blah')
+    expect(element[0]).to be_instance_of Druid::Elements::FileField
+  end
+
+  it "should find all file fields using no identifier" do
+    expect(driver).to receive(:file_fields).with({}).and_return([driver])
+    page.file_field_elements
+  end
+
   it "should find a label" do
     expect(driver).to receive(:label).with(:id => 'blah').and_return(driver)
     element = page.label_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Label
   end
 
+  it "should find a label element using a default identifier" do
+    expect(driver).to receive(:label).with(:index => 0).and_return(driver)
+    page.label_element
+  end
+
   it "should find all label elements" do
     expect(driver).to receive(:labels).with(:id => 'blah').and_return([driver])
     elements = page.label_elements(:id => 'blah')
     expect(elements[0]).to be_instance_of Druid::Elements::Label
   end
+
+  it "should find all labels using no identifier" do
+    expect(driver).to receive(:labels).with({}).and_return([driver])
+    page.label_elements
+  end
+
+  it "should find an element" do
+    expect(driver).to receive(:audio).with(:id => 'blah').and_return(driver)
+    element = page.element(:audio, :id => 'blah')
+    expect(element).to be_instance_of Druid::Elements::Element
+  end
+
+  it "should find an element using a default identifier" do
+    expect(driver).to receive(:audio).with(:index => 0).and_return(driver)
+    page.element(:audio)
+  end
 end