druid-ts 1.1.0 → 1.1.1

data/lib/druid/nested_elements.rb

@@ -4,98 +4,194 @@ module Druid
       link_for(identifier)
     end
 
+    def link_elements(identifier={:index => 0})
+      links_for(identifier)
+    end
+
     def button_element(identifier={:index => 0})
       button_for(identifier)
     end
 
+    def button_elements(identifier={:index => 0})
+      buttons_for(identifier)
+    end
+
     def text_field_element(identifier={:index => 0})
       text_field_for(identifier)
     end
 
+    def text_field_elements(identifier={:index => 0})
+      text_fields_for(identifier)
+    end
+
     def hidden_field_element(identifier={:index => 0})
       hidden_field_for(identifier)
     end
 
+    def hidden_field_elements(identifier={:index => 0})
+      hidden_fields_for(identifier)
+    end
+
     def text_area_element(identifier={:index => 0})
       text_area_for(identifier)
     end
 
+    def text_area_elements(identifier={:index => 0})
+      text_areas_for(identifier)
+    end
+
     def select_list_element(identifier={:index => 0})
       select_list_for(identifier)
     end
 
+    def select_list_elements(identifier={:index => 0})
+      select_lists_for(identifier)
+    end
+
     def checkbox_element(identifier={:index => 0})
       checkbox_for(identifier)
     end
 
+    def checkbox_elements(identifier={:index => 0})
+      checkboxs_for(identifier)
+    end
+
     def radio_button_element(identifier={:index => 0})
       radio_button_for(identifier)
     end
 
+    def radio_button_elements(identifier={:index => 0})
+      radio_buttons_for(identifier)
+    end
+
     def div_element(identifier={:index => 0})
       div_for(identifier)
     end
 
+    def div_elements(identifier={:index => 0})
+      divs_for(identifier)
+    end
+
     def span_element(identifier={:index => 0})
       span_for(identifier)
     end
 
+    def span_elements(identifier={:index => 0})
+      spans_for(identifier)
+    end
+
     def table_element(identifier={:index => 0})
       table_for(identifier)
     end
 
+    def table_elements(identifier={:index => 0})
+      tables_for(identifier)
+    end
+
     def cell_element(identifier={:index => 0})
       cell_for(identifier)
     end
 
+    def cell_elements(identifier={:index => 0})
+      cells_for(identifier)
+    end
+
     def image_element(identifier={:index => 0})
       image_for(identifier)
     end
 
+    def image_elements(identifier={:index => 0})
+      images_for(identifier)
+    end
+
     def form_element(identifier={:index => 0})
       form_for(identifier)
     end
 
+    def form_elements(identifier={:index => 0})
+      forms_for(identifier)
+    end
+
     def ordered_list_element(identifier={:index => 0})
       ordered_list_for(identifier)
     end
 
+    def ordered_list_elements(identifier={:index => 0})
+      ordered_lists_for(identifier)
+    end
+
     def unordered_list_element(identifier={:index => 0})
       unordered_list_for(identifier)
     end
 
+    def unordered_list_elements(identifier={:index => 0})
+      unordered_lists_for(identifier)
+    end
+
     def list_item_element(identifier={:index => 0})
       list_item_for(identifier)
     end
 
+    def list_item_elements(identifier={:index => 0})
+      list_items_for(identifier)
+    end
+
     def h1_element(identifier={:index => 0})
       h1_for(identifier)
     end
 
+    def h1_elements(identifier={:index => 0})
+      h1s_for(identifier)
+    end
+
     def h2_element(identifier={:index => 0})
       h2_for(identifier)
     end
 
+    def h2_elements(identifier={:index => 0})
+      h2s_for(identifier)
+    end
+
     def h3_element(identifier={:index => 0})
       h3_for(identifier)
     end
 
+    def h3_elements(identifier={:index => 0})
+      h3s_for(identifier)
+    end
+
     def h4_element(identifier={:index => 0})
       h4_for(identifier)
     end
 
+    def h4_elements(identifier={:index => 0})
+      h4s_for(identifier)
+    end
+
     def h5_element(identifier={:index => 0})
       h5_for(identifier)
     end
 
+    def h5_elements(identifier={:index => 0})
+      h5s_for(identifier)
+    end
+
     def h6_element(identifier={:index => 0})
       h6_for(identifier)
     end
 
+    def h6_elements(identifier={:index => 0})
+      h6s_for(identifier)
+    end
+
     def paragraph_element(identifier={:index => 0})
       paragraph_for(identifier)
     end
 
+    def paragraph_elements(identifier={:index => 0})
+      paragraphs_for(identifier)
+    end
+
     def file_field_element(identifier={:index =>0})
       file_field_for(identifier)
     end

data/lib/druid/page_factory.rb

@@ -18,6 +18,16 @@ module Druid
   #     page.name.should == 'Tim'
   #   end
   #
+  # If you plan to use the navigate_to method you will need to ensure you setup the possible
+  # routes ahead of time. You must always have a default route in order for this to work. Here
+  # is an example of how you define routes:
+  #
+  # @example Example routes defined in env.rb
+  #  Druid::PageFactory.routes = {
+  #    :default => [[PageOne,:method1], [PageTwoA,:method2], [PageThree,:method3],
+  #    :another_route => [[PageOne,:method1], [PageTwoB,:method2b], [PageThree,:method3]]
+  #   }
+  # You must also call the navigation_method on each page.
   module PageFactory
     # attr_accessor :page
     #
@@ -41,18 +51,85 @@ module Druid
     #
     def on_page(page_class, visit=false, &block)
       @current_page = page_class.new(@driver, visit)
-      yield @current_page if block_given?
+      block.call @current_page if block
       @current_page
     end
-    # def visit_page(page_class, &block)
-    #   page = page_class.new(@driver, true)
-    #   yield page if block_given?
-    #   page
-    # end
+
+    #
+    # Navigate to a specific page following a predefined path.
+    #
+    # This method requires a lot of setup.  See the documentation for
+    # this class.  Once the setup is complete you can navigate to a
+    # page traversing through all other pages along the way.  It will
+    # call the method you specified in the routes for each
+    # page as it navigates.  Using the example setup defined in the
+    # documentation above you can call the method two ways:
+    #
+    # @example
+    #   page.navigate_to(PageThree)  # will use the default path
+    #   page.navigate_to(PageThree, :using => :another_route)
+    #
+    # @param [PageObject]  a class that has included the PageObject
+    # module and which has the navigation_method defined
+    # @param [Hash] a hash that contains an element with the key
+    # :using.  This will be used to lookup the route.  It has a
+    # default value of :default.
+    # @param [block]  an optional block to be called
+    # @return [PageObject] the page you are navigating to
+    #
+    def navigate_to(page_cls, how = {:using => :default}, &block)
+      path = path_for how
+      to_index = find_index_for(path, page_cls)-1
+      navigate_through_pages(path[0..to_index])
+      on_page(page_cls, &block)
+    end
+
     #
-    # def on_page(page, &block)
-    #   yield page if block_given?
-    #   page
-    # end
+    # Same as navigate_to except it will start at the @current_page
+    # instead the beginning of the path.
+    #
+    # @param [Druid] a class that has included the Druid
+    # module and which has the navigation_method defined
+    # @param [Hash] a hash that contains an element with the key
+    # :using. This will be used to lookup the route. It has a default value of :default.
+    # @param [block] an optional block to be called
+    # @return [Druid] the page you are navigating to
+    #
+    def continue_navigation_to(page_cls, how = {:using => :default}, &block)
+      path = path_for how
+      from_index = find_index_for(path, @current_page.class)+1
+      to_index = find_index_for(path, page_cls)-1
+      navigate_through_pages(path[from_index..to_index])
+      on_page(page_cls, &block)
+    end
+
+    private
+
+    def path_for(how)
+      path = Druid::PageFactory.page_object_routes[how[:using]]
+      fail("PageFactory route :#{how[:using].to_s} not found") unless path
+      path
+    end
+
+    def navigate_through_pages(pages)
+      pages.each do |cls, method|
+        page = on_page(cls)
+        fail("Navigation method not specified on #{cls}.  Please call the ") unless page.respond_to? method
+        page.send method
+      end
+    end
+
+    def find_index_for(path, item)
+      path.each_with_index { |each, index| return index if each[0] == item }
+    end
+
+    class << self
+      attr_accessor :page_object_routes
+
+      def routes=(routes)
+        raise("You must provide a :default route for PageFactory routes") unless routes[:default]
+        @page_object_routes = routes
+      end
+    end
   end
 end

data/lib/druid/version.rb

@@ -0,0 +1,3 @@
+module Druid
+  VERSION = "1.1.1"
+end

data/spec/druid/element_locators_spec.rb

@@ -14,144 +14,291 @@ describe Druid::ElementLocators do
     expect(button).to be_instance_of Druid::Elements::Button
   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 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 all text field elemnts" do
+    expect(driver).to receive(:text_fields).with(:id => 'blah').and_return([driver])
+    elements = page.text_field_elements(:id => 'blah')
+    expect(elements[0]).to be_instance_of Druid::Elements::TextField
+  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 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 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 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 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 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 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 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 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 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 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 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 a div element" do
     expect(driver).to receive(:div).with(:id => 'blah').and_return(driver)
     element = page.div_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Div
   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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 an unordered list element" do
     expect(driver).to receive(:ul).with(:id => 'blah').and_return(driver)
     element = page.unordered_list_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::UnOrderedList
   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 a h1 element" do
     expect(driver).to receive(:h1).with(:id => 'blah').and_return(driver)
     element = page.h1_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Heading
   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 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 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 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 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 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 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 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 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 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 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 a paragraph element" do
     expect(driver).to receive(:p).with(:id => 'blah').and_return(driver)
     element = page.paragraph_element(:id => 'blah')
     expect(element).to be_instance_of Druid::Elements::Paragraph
   end
 
+  it "should find all paragraph elements" do
+    expect(driver).to receive(:ps).with(:id => 'blah').and_return([driver])
+    elements = page.paragraph_elements(:id => 'blah')
+    expect(elements[0]).to be_instance_of Druid::Elements::Paragraph
+  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')