druid-ts 0.0.1 → 1.1.0

data/lib/druid/elements/ordered_list.rb

@@ -8,11 +8,8 @@ module Druid
       end
 
       def [](idx)
-        if element.li(:xpath, ".//li[#{idx+1}]").exist?
-          element.li(:xpath, ".//li[#{idx+1}]")
-        else
-          print "the sub element of ol is not li"+"\n"
-        end
+        li = element.li(:xpath, ".//li[#{idx+1}]")
+        Druid::Elements::ListItem.new(li)
       end
 
       def items
@@ -26,5 +23,7 @@ module Druid
       end
 
     end
+
+    Druid::Elements.tag_to_class[:ol] = Druid::Elements::OrderedList
   end
 end

data/lib/druid/elements/paragraph.rb

@@ -0,0 +1,9 @@
+module Druid
+  module Elements
+    class Paragraph < Element
+
+    end
+
+    Druid::Elements.tag_to_class[:p] = Druid::Elements::Paragraph
+  end
+end

data/lib/druid/elements/radio_button.rb

@@ -2,6 +2,31 @@ module Druid
   module Elements
     class RadioButton < Element
 
+      def self.finders
+        super + [:value]
+      end
+      #
+      # Select the RadioButton
+      #
+      def select
+        element.set
+      end
+
+      #
+      # Clear the RadioButton
+      #
+      def clear
+        element.clear
+      end
+
+      #
+      # Return if it is selected
+      #
+      def selected?
+        element.set?
+      end
     end
+
+    Druid::Elements.type_to_class[:radio] = Druid::Elements::RadioButton
   end
 end

data/lib/druid/elements/select_list.rb

@@ -7,12 +7,21 @@ module Druid
       end
 
       def [](idx)
-        element.options[idx]
+        Druid::Elements::Option.new(options[idx])
       end
 
       def options
         element.options
       end
+
+      #
+      # Select a value from the list
+      #
+      def select(value)
+        element.select(value)
+      end
     end
+
+    Druid::Elements.tag_to_class[:select] = Druid::Elements::SelectList
   end
 end

data/lib/druid/elements/span.rb

@@ -3,9 +3,11 @@ module Druid
     class Span < Element
 
       def self.finders
-        [:class, :id, :index, :xpath]
+        [:class, :id, :index, :xpath, :text]
       end
 
     end
+
+    Druid::Elements.tag_to_class[:span] = Druid::Elements::Span
   end
 end

data/lib/druid/elements/table.rb

@@ -1,7 +1,6 @@
 module Druid
   module Elements
     class Table < Element
-
       #
       # Return the Druid::Elements::Table for the index provided.  Index
       # is zero based.
@@ -25,6 +24,26 @@ module Druid
         end
       end
 
+      #
+      # return the first row
+      #
+      # @return Druid::Elements::TableRow
+      #
+      def first_row
+        self[0]
+      end
+
+      #
+      # return the last row
+      #
+      # @return Druid::Elements::TableRow
+      #
+      def last_row
+        self[-1]
+      end
+
     end
+
+    Druid::Elements.tag_to_class[:table] = Druid::Elements::Table
   end
 end

data/lib/druid/elements/table_cell.rb

@@ -2,6 +2,13 @@ module Druid
   module Elements
     class TableCell < Element
 
+      def self.finders
+        super + [:text]
+      end
     end
+
+    Druid::Elements.tag_to_class[:td] = Druid::Elements::TableCell
+    Druid::Elements.tag_to_class[:th] = Druid::Elements::TableCell
+
   end
 end

data/lib/druid/elements/table_row.rb

@@ -2,7 +2,8 @@ module Druid
   module Elements
     class TableRow < Element
       def [](idx)
-        element[idx]
+        table_cell = element[idx]
+        Druid::Elements::TableCell.new(table_cell)
       end
       #
       # Returns the number of rows in the table.
@@ -18,5 +19,8 @@ module Druid
       end
 
     end
+
+    Druid::Elements.tag_to_class[:tr] = Druid::Elements::TableRow
+
   end
 end

data/lib/druid/elements/text_area.rb

@@ -3,9 +3,23 @@ module Druid
     class TextArea < Element
 
       def self.finders
-        super + [:tag_name, :css]
+        super + [:tag_name]
+      end
+
+      def self.mapping
+        super.merge({:css => :tag_name})
+      end
+
+      #
+      # Set the value of the TextArea
+      #
+      def value=(new_value)
+        element.send_keys(new_value)
       end
 
     end
+
+    Druid::Elements.tag_to_class[:textarea] = Druid::Elements::TextArea
+
   end
 end

data/lib/druid/elements/text_field.rb

@@ -3,9 +3,19 @@ module Druid
     class TextField < Element
 
       def self.finders
-        super + [:css, :tag_name, :text]
+        super + [:css, :tag_name, :text, :title]
       end
 
+      #
+      # Set the value of the TextField
+      #
+      def value=(new_value)
+        element.set(new_value)
+      end
     end
+
+    Druid::Elements.type_to_class[:text] = Druid::Elements::TextField
+    Druid::Elements.type_to_class[:password] = Druid::Elements::TextField
+
   end
 end

data/lib/druid/elements/unordered_list.rb

@@ -7,11 +7,8 @@ module Druid
       end
 
       def [](idx)
-        if element.li(:xpath,".//li[#{idx+1}]").exist?
-          element.li(:xpath,".//li[#{idx+1}]")
-        else
-          print "the sub element of ul is not li"+"\n"
-        end
+        li = element.li(:xpath,".//li[#{idx+1}]")
+        Druid::Elements::ListItem.new(li)
       end
 
       def items
@@ -24,5 +21,8 @@ module Druid
         end
       end
     end
+
+    Druid::Elements.tag_to_class[:ul] = Druid::Elements::UnOrderedList
+
   end
 end

data/lib/druid/nested_elements.rb

@@ -0,0 +1,103 @@
+module Druid
+  module NestedElements
+    def link_element(identifier={:index => 0})
+      link_for(identifier)
+    end
+
+    def button_element(identifier={:index => 0})
+      button_for(identifier)
+    end
+
+    def text_field_element(identifier={:index => 0})
+      text_field_for(identifier)
+    end
+
+    def hidden_field_element(identifier={:index => 0})
+      hidden_field_for(identifier)
+    end
+
+    def text_area_element(identifier={:index => 0})
+      text_area_for(identifier)
+    end
+
+    def select_list_element(identifier={:index => 0})
+      select_list_for(identifier)
+    end
+
+    def checkbox_element(identifier={:index => 0})
+      checkbox_for(identifier)
+    end
+
+    def radio_button_element(identifier={:index => 0})
+      radio_button_for(identifier)
+    end
+
+    def div_element(identifier={:index => 0})
+      div_for(identifier)
+    end
+
+    def span_element(identifier={:index => 0})
+      span_for(identifier)
+    end
+
+    def table_element(identifier={:index => 0})
+      table_for(identifier)
+    end
+
+    def cell_element(identifier={:index => 0})
+      cell_for(identifier)
+    end
+
+    def image_element(identifier={:index => 0})
+      image_for(identifier)
+    end
+
+    def form_element(identifier={:index => 0})
+      form_for(identifier)
+    end
+
+    def ordered_list_element(identifier={:index => 0})
+      ordered_list_for(identifier)
+    end
+
+    def unordered_list_element(identifier={:index => 0})
+      unordered_list_for(identifier)
+    end
+
+    def list_item_element(identifier={:index => 0})
+      list_item_for(identifier)
+    end
+
+    def h1_element(identifier={:index => 0})
+      h1_for(identifier)
+    end
+
+    def h2_element(identifier={:index => 0})
+      h2_for(identifier)
+    end
+
+    def h3_element(identifier={:index => 0})
+      h3_for(identifier)
+    end
+
+    def h4_element(identifier={:index => 0})
+      h4_for(identifier)
+    end
+
+    def h5_element(identifier={:index => 0})
+      h5_for(identifier)
+    end
+
+    def h6_element(identifier={:index => 0})
+      h6_for(identifier)
+    end
+
+    def paragraph_element(identifier={:index => 0})
+      paragraph_for(identifier)
+    end
+
+    def file_field_element(identifier={:index =>0})
+      file_field_for(identifier)
+    end
+  end
+end

data/lib/druid/page_factory.rb

@@ -19,7 +19,7 @@ module Druid
   #   end
   #
   module PageFactory
-    attr_accessor :page
+    # attr_accessor :page
     #
     # Create and navigate to a page object.  The navigation will only work if the
     # 'page_url' method was call on the page object.
@@ -40,9 +40,9 @@ module Druid
     # @return [PageObject] the newly created page object
     #
     def on_page(page_class, visit=false, &block)
-      page = page_class.new(@driver, visit)
-      yield page if block_given?
-      page
+      @current_page = page_class.new(@driver, visit)
+      yield @current_page if block_given?
+      @current_page
     end
     # def visit_page(page_class, &block)
     #   page = page_class.new(@driver, true)

data/lib/druid/page_populator.rb

@@ -0,0 +1,71 @@
+module Druid
+  module PagePopulator
+    #
+    # This method will populate all matched page TextFields,
+    # TextAreas, SelectLists, FileFields, Checkboxes, and Radio Buttons from the
+    # Hash passed as an argument.  The way it find an element is by
+    # matching the Hash key to the name you provided when declaring
+    # the element on your page.
+    #
+    # Checkbox and Radio Button values must be true or false.
+    #
+    # @example
+    #   class ExamplePage
+    #     include PageObject
+    #
+    #     text_field(:username, :id => 'username_id')
+    #     checkbox(:active, :id => 'active_id')
+    #   end
+    #
+    #   ...
+    #
+    #   @browser = Watir::Browser.new :firefox
+    #   example_page = ExamplePage.new(@browser)
+    #   example_page.populate_page_with :username => 'a name', :active => true
+    #
+    # @param [Hash] the data to use to populate this page.  The key
+    # can be either a string or a symbol.  The value must be a string
+    # for TextField, TextArea, SelectList and FileField must be true or
+    # false for a Checkbox or RadioButton.
+    #
+    def populate_page_with(data)
+      data.each do |key, value|
+        populate_checkbox(key, value) if is_checkbox?(key) and is_enabled?(key)
+        populate_radiobutton(key, value) if is_radiobutton?(key) and is_enabled?(key)
+        populate_text(key, value) if is_text?(key) and is_enabled?(key)
+      end
+    end
+
+    private
+
+    def populate_text(key, value)
+      self.send "#{key}=", value
+    end
+
+    def populate_checkbox(key, value)
+      return self.send "check_#{key}" if value
+      return self.send "uncheck_#{key}"
+    end
+
+    def populate_radiobutton(key, value)
+      return self.send "select_#{key}" if value
+      return self.send "clear_#{key}"
+    end
+
+    def is_text?(key)
+      respond_to?("#{key}=".to_sym)
+    end
+
+    def is_checkbox?(key)
+      respond_to?("check_#{key}".to_sym)
+    end
+
+    def is_radiobutton?(key)
+      respond_to?("select_#{key}".to_sym)
+    end
+
+    def is_enabled?(key)
+      self.send("#{key}_element").enabled?
+    end
+  end
+end

data/spec/druid/accessors_spec.rb

@@ -0,0 +1,789 @@
+require 'spec_helper'
+
+class AccessorsTestDruid
+  include Druid
+
+  page_url "http://apple.com"
+  link(:google_search, :link => 'Google Search')
+  text_field(:first_name, :id => 'first_name')
+  select_list(:state, :id => 'state')
+  checkbox(:active, :id => 'is_active_id')
+  button(:click_me, :id => 'button_submit')
+  radio_button(:first, :id => 'first_choice')
+  div(:message, :id => 'message_id')
+  table(:cart, :id => 'cart_id')
+  cell(:total, :id => 'total')
+  span(:alert, :id => 'alert_id')
+  image(:logo, :id => 'logo')
+  hidden_field(:social_security_number, :id => 'ssn')
+  form(:login, :id => 'login')
+  text_area(:address, :id => 'address')
+  list_item(:item_one, :id => 'one')
+  unordered_list(:menu, :id => 'main_menu')
+  ordered_list(:top_five, :id => 'top')
+  h1(:heading1, :id => 'main_heading')
+  h2(:heading2, :id => 'main_heading')
+  h3(:heading3, :id => 'main_heading')
+  h4(:heading4, :id => 'main_heading')
+  h5(:heading5, :id => 'main_heading')
+  h6(:heading6, :id => 'main_heading')
+  paragraph(:first_para, :id => 'first')
+  file_field(:upload_me, :id => 'the_file')
+end
+
+class BlockDruid
+  include Druid
+
+  text_field :first_name do |element|
+    "text_field"
+  end
+  hidden_field :secret do |element|
+    "hidden_field"
+  end
+  text_area :address do |element|
+    "text_area"
+  end
+  select_list :state do |element|
+    "select_list"
+  end
+  link :continue do |element|
+    "link"
+  end
+  checkbox :active do |element|
+    "checkbox"
+  end
+  radio_button :first do |element|
+    "radio_button"
+  end
+  button :click_me do |element|
+    "button"
+  end
+  div :footer do |element|
+    "div"
+  end
+  span :alert do |element|
+    "span"
+  end
+  table :cart do |element|
+    "table"
+  end
+  cell :total do |element|
+    "cell"
+  end
+  image :logo do |element|
+    "image"
+  end
+  form :login do |element|
+    "form"
+  end
+  list_item :item_one do |element|
+    "list_item"
+  end
+  unordered_list :menu do |element|
+    "unordered_list"
+  end
+  ordered_list :top_five do |element|
+    "ordered_list"
+  end
+  h1 :heading1 do |element|
+    "h1"
+  end
+  h2 :heading2 do |element|
+    "h2"
+  end
+  h3 :heading3 do |element|
+    "h3"
+  end
+  h4 :heading4 do |element|
+    "h4"
+  end
+  h5 :heading5 do |element|
+    "h5"
+  end
+  h6 :heading6 do |element|
+    "h6"
+  end
+  paragraph :first_para do |element|
+    "p"
+  end
+  file_field :a_file do |element|
+    "file_field"
+  end
+end
+
+class TestDruidBackUp
+  include Druid
+end
+
+describe Druid::Accessors do
+  let(:driver) { mock_driver }
+  let(:druid) { AccessorsTestDruid.new(driver) }
+  let(:block_druid) { BlockDruid.new(driver) }
+
+
+  describe "goto a page" do
+    it "should navigate to a page when requested" do
+      expect(driver).to receive(:goto)
+      page = AccessorsTestDruid.new(driver, true)
+    end
+
+    it "should not navigate to a page when not requested" do
+      expect(driver).not_to receive(:goto)
+      page = AccessorsTestDruid.new(driver)
+    end
+
+    it "should not navigate to a page when 'page_url' not specified" do
+      expect(driver).not_to receive(:goto)
+      page = TestDruidBackUp.new(driver,true)
+    end
+  end
+
+  describe "check_box accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :check_active
+        expect(druid).to respond_to :uncheck_active
+        expect(druid).to respond_to :active_checked?
+        expect(druid).to respond_to :active_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.active_element).to eql "checkbox"
+      end
+    end
+
+    context "implementation" do
+      it "should check a check box element" do
+        expect(driver).to receive_message_chain(:checkbox, :set)
+        druid.check_active
+      end
+
+      it "should clear a check box element" do
+        expect(driver).to receive_message_chain(:checkbox, :clear)
+        druid.uncheck_active
+      end
+
+      it "should know if a check box element is selected" do
+        expect(driver).to receive_message_chain(:checkbox, :set?).and_return(true)
+        expect(druid.active_checked?).to be true
+      end
+
+      it "should retreive a check box element" do
+        expect(driver).to receive(:checkbox)
+        expect(druid.active_element).to be_instance_of Druid::Elements::CheckBox
+      end
+    end
+  end
+
+  describe "link accessors" do
+
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:google_search)
+        expect(druid).to respond_to(:google_search_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.continue_element).to eql "link"
+      end
+    end
+
+    context "implementation" do
+      it "should select a link" do
+        expect(driver).to receive_message_chain(:link, :click)
+        druid.google_search
+      end
+
+      it "should retreive a link element" do
+        expect(driver).to receive(:link)
+        expect(druid.google_search_element).to be_instance_of Druid::Elements::Link
+      end
+    end
+  end
+
+  describe "select_list accessors" do
+
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :state
+        expect(druid).to respond_to :state=
+        expect(druid).to respond_to :state_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.state_element).to eql "select_list"
+      end
+    end
+
+    context "implementation" do
+      it "should get the current item from a select list" do
+        expect(driver).to receive_message_chain(:select_list, :value).and_return('OH')
+        expect(druid.state).to eql 'OH'
+      end
+
+      it "should set the current item fo a select list" do
+        expect(driver).to receive(:select_list).and_return driver
+        expect(driver).to receive(:select).with('OH')
+        druid.state = 'OH'
+      end
+
+      it "should retreive a select list element" do
+        expect(driver).to receive(:select_list)
+        expect(druid.state_element).to be_instance_of Druid::Elements::SelectList
+      end
+    end
+  end
+
+  describe "text_field accessors" do
+
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:first_name)
+        expect(druid).to respond_to(:first_name=)
+        expect(druid).to respond_to(:first_name_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.first_name_element).to eql "text_field"
+      end
+    end
+
+    context "implementation" do
+      it "should get the text from the text field element" do
+        expect(driver).to receive_message_chain(:text_field, :value).and_return('Kim')
+        expect(druid.first_name).to eql 'Kim'
+      end
+
+      it "should set some text on a text field element" do
+        expect(driver).to receive_message_chain(:text_field, :set).with('Kim')
+        druid.first_name = 'Kim'
+      end
+
+      it "should retreive text field element" do
+        expect(driver).to receive(:text_field)
+        expect(druid.first_name_element).to be_instance_of Druid::Elements::TextField
+      end
+    end
+  end
+
+  describe "button accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :click_me
+        expect(druid).to respond_to :click_me_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.click_me_element).to eql "button"
+      end
+    end
+
+    context "implementation" do
+      it "should select a button" do
+        expect(driver).to receive_message_chain(:button, :click)
+        druid.click_me
+      end
+
+      it "should retreive a button element" do
+        expect(driver).to receive(:button)
+        expect(druid.click_me_element).to be_instance_of Druid::Elements::Button
+      end
+    end
+  end
+
+  describe "radio accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :first_element
+        expect(druid).to respond_to :select_first
+        expect(druid).to respond_to :first_selected?
+        expect(druid).to respond_to :clear_first
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.first_element).to eql "radio_button"
+      end
+    end
+
+    context "implementation" do
+      it "should select a radio button" do
+        expect(driver).to receive_message_chain(:radio, :set)
+        druid.select_first
+      end
+
+      it "should clear a radio button" do
+        expect(driver).to receive_message_chain(:radio, :clear)
+        druid.clear_first
+      end
+
+      it "should determine if a radio is selected" do
+        expect(driver).to receive_message_chain(:radio, :set?).and_return(true)
+        expect(druid.first_selected?).to be true
+      end
+
+      it "should retreive a radio button element" do
+        expect(driver).to receive(:radio)
+        expect(druid.first_element).to be_instance_of Druid::Elements::RadioButton
+      end
+    end
+  end
+
+  describe "div accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :message
+        expect(druid).to respond_to :message_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.footer_element).to eql "div"
+      end
+    end
+
+    context "implementation" do
+      it "should retreive the text from a div" do
+        expect(driver).to receive_message_chain(:div, :text).and_return("Message from div")
+        expect(druid.message).to eql "Message from div"
+      end
+
+      it "should retreive a div element" do
+        expect(driver).to receive(:div)
+        expect(druid.message_element).to be_instance_of Druid::Elements::Div
+      end
+    end
+  end
+
+  describe "table accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :cart_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.cart_element).to eql "table"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the table element from the page" do
+        expect(driver).to receive(:table)
+        expect(druid.cart_element).to be_instance_of Druid::Elements::Table
+      end
+    end
+  end
+
+  describe "table cell accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :total
+        expect(druid).to respond_to :total_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.total_cell).to eql "cell"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the cell" do
+        expect(driver).to receive_message_chain(:td, :text).and_return("10.00")
+        expect(druid.total).to eql "10.00"
+      end
+
+      it "should retrieve the cell element from the page" do
+        expect(driver).to receive(:td)
+        expect(druid.total_element).to be_instance_of Druid::Elements::TableCell
+      end
+    end
+  end
+
+  describe "span accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :alert
+        expect(druid).to respond_to :alert_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.alert_element).to eql "span"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from a span" do
+        expect(driver).to receive_message_chain(:span, :text).and_return('Alert')
+        expect(druid.alert).to eql 'Alert'
+      end
+
+      it "should retrieve the span element from the page" do
+        expect(driver).to receive(:span)
+        expect(druid.alert_element).to be_instance_of Druid::Elements::Span
+      end
+    end
+  end
+
+  describe "image accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :logo_element
+      end
+
+      it "should call a block on the element method when present " do
+        expect(block_druid.logo_element).to eql "image"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the image element from the page" do
+        expect(driver).to receive(:image)
+        expect(druid.logo_element).to be_instance_of Druid::Elements::Image
+      end
+    end
+  end
+
+  describe "hidden field accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :social_security_number
+        expect(druid).to respond_to :social_security_number_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.secret_element).to eql "hidden_field"
+      end
+    end
+
+    context "implementation" do
+      it "should get the text from a hidden field" do
+        expect(driver).to receive_message_chain(:hidden, :value).and_return('value')
+        expect(druid.social_security_number).to eql 'value'
+      end
+
+      it "should retrieve a hidden field element" do
+        expect(driver).to receive(:hidden)
+        expect(druid.social_security_number_element).to be_instance_of Druid::Elements::HiddenField
+      end
+    end
+  end
+
+  describe "form accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :login_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.login_element).to eql "form"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the form element from the page" do
+        expect(driver).to receive(:form)
+        expect(druid.login_element).to be_instance_of Druid::Elements::Form
+      end
+    end
+  end
+
+  describe "text area accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :address
+        expect(druid).to respond_to :address=
+        expect(druid).to respond_to :address_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.address_element).to eql "text_area"
+      end
+    end
+
+    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')
+        druid.address='123 main street'
+      end
+
+      it "should get the text from the text area" do
+        expect(driver).to receive_message_chain(:textarea, :value).and_return('123 main street')
+        expect(druid.address).to eql '123 main street'
+      end
+
+      it "should retrieve a text area element" do
+        expect(driver).to receive(:textarea)
+        expect(druid.address_element).to be_instance_of Druid::Elements::TextArea
+      end
+    end
+  end
+
+  describe "list item accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :item_one
+        expect(druid).to respond_to :item_one_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.item_one_element).to eql "list_item"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the list item" do
+        expect(driver).to receive_message_chain(:li, :text).and_return('value')
+        expect(druid.item_one).to eql 'value'
+      end
+
+      it "should retrieve the list item element from the page" do
+        expect(driver).to receive(:li)
+        expect(druid.item_one_element).to be_instance_of Druid::Elements::ListItem
+      end
+    end
+  end
+
+  describe "unordered list accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :menu_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.menu_element).to eql "unordered_list"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:ul)
+        expect(druid.menu_element).to be_instance_of Druid::Elements::UnOrderedList
+      end
+    end
+  end
+
+  describe "ordered list accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :top_five_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.top_five_element).to eql "ordered_list"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:ol)
+        expect(druid.top_five_element).to be_instance_of Druid::Elements::OrderedList
+      end
+    end
+  end
+
+  describe "h1 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to :heading1
+        expect(druid).to respond_to :heading1_element
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.heading1_element).to eql "h1"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the h1" do
+        expect(driver).to receive(:h1).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.heading1).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:h1).and_return(driver)
+        expect(druid.heading1_element).to be_instance_of Druid::Elements::Heading
+      end
+    end
+  end
+
+  describe "h2 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:heading2)
+        expect(druid).to respond_to(:heading2_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.heading2_element).to eql "h2"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the h2" do
+        expect(driver).to receive(:h2).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.heading2).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:h2).and_return(driver)
+        expect(druid.heading2_element).to be_instance_of Druid::Elements::Heading
+      end
+    end
+  end
+
+  describe "h3 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:heading3)
+        expect(druid).to respond_to(:heading3_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.heading3_element).to eql "h3"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the h3" do
+        expect(driver).to receive(:h3).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.heading3).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:h3).and_return(driver)
+        expect(druid.heading3_element).to be_instance_of Druid::Elements::Heading
+      end
+    end
+  end
+
+  describe "h4 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:heading4)
+        expect(druid).to respond_to(:heading4_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.heading4_element).to eql "h4"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the h4" do
+        expect(driver).to receive(:h4).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.heading4).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:h4).and_return(driver)
+        expect(druid.heading4_element).to be_instance_of Druid::Elements::Heading
+      end
+    end
+  end
+
+  describe "h5 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:heading5)
+        expect(druid).to respond_to(:heading5_element)
+      end
+
+      it "should call a block on the element method present" do
+        expect(block_druid.heading5_element).to eql "h5"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the h5" do
+        expect(driver).to receive(:h5).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.heading5).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:h5).and_return(driver)
+        expect(druid.heading5_element).to be_instance_of Druid::Elements::Heading
+      end
+    end
+  end
+
+  describe "h6 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:heading6)
+        expect(druid).to respond_to(:heading6_element)
+      end
+
+      it "should call a block on the element method present" do
+        expect(block_druid.heading6_element).to eql "h6"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the h6" do
+        expect(driver).to receive(:h6).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.heading6).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:h6).and_return(driver)
+        expect(druid.heading6_element).to be_instance_of Druid::Elements::Heading
+      end
+    end
+  end
+
+  describe "paragraph accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        expect(druid).to respond_to(:first_para)
+        expect(druid).to respond_to(:first_para_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.first_para_element).to eql "p"
+      end
+    end
+
+    context "implementation" do
+      it "should retrieve the text from the p" do
+        expect(driver).to receive(:p).and_return(driver)
+        expect(driver).to receive(:text).and_return("value")
+        expect(druid.first_para).to eql "value"
+      end
+
+      it "should retrieve the element from the page" do
+        expect(driver).to receive(:p).and_return(driver)
+        expect(druid.first_para_element).to be_instance_of Druid::Elements::Paragraph
+      end
+    end
+  end
+
+  describe "file_field accessors" do
+    context "when called on a page object" do
+      it "should geneate accessor methods" do
+        expect(druid).to respond_to(:upload_me=)
+        expect(druid).to respond_to(:upload_me_element)
+      end
+
+      it "should call a block on the element method when present" do
+        expect(block_druid.a_file_element).to eql "file_field"
+      end
+    end
+
+    context "implementation" do
+      it "should set the file name" do
+        expect(driver).to receive(:file_field).and_return(driver)
+        expect(driver).to receive(:set).with('some_file')
+        druid.upload_me = 'some_file'
+      end
+
+      it "should retrieve a file field element" do
+        expect(driver).to receive(:file_field).and_return(driver)
+        expect(druid.upload_me_element).to be_instance_of Druid::Elements::FileField
+      end
+    end
+  end
+end