druid-ts 1.2.0 → 1.2.1

data/lib/druid/elements/italic.rb

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

data/lib/druid/elements/option.rb

@@ -2,6 +2,12 @@ module Druid
   module Elements
     class Option < Element
 
+      #
+      # returns true if the option is selected
+      #
+      def selected?
+        element.selected?
+      end
     end
 
     Druid::Elements.tag_to_class[:option] = Druid::Elements::Option

data/lib/druid/elements/ordered_list.rb

@@ -21,19 +21,21 @@ module Druid
         end
       end
 
+      def list_items
+        children.collect do |obj|
+          Druid::Elements::ListItem.new(obj)
+        end
+      end
+
       protected
 
       def child_xpath
-        ".//child::li"
+        "./child::li"
       end
 
       private
 
       def children
-        list_items.find_all { |item| item.parent == element }
-      end
-
-      def list_items
         element.ols(:xpath => child_xpath)
       end
 

data/lib/druid/elements/text_area.rb

@@ -12,6 +12,20 @@ module Druid
         element.set(new_value)
       end
 
+      #
+      # Clear the TextArea
+      #
+      def clear
+        element.clear
+      end
+
+      #
+      # append the text to the end of the text in the text area
+      #
+      def append(text)
+        element.append(text)
+      end
+
     end
 
     Druid::Elements.tag_to_class[:textarea] = Druid::Elements::TextArea

data/lib/druid/elements/text_field.rb

@@ -14,7 +14,7 @@ module Druid
       end
 
       def append text
-        element.send_keys text
+        element.append text
       end
     end
 

data/lib/druid/elements/unordered_list.rb

@@ -20,19 +20,25 @@ module Druid
         end
       end
 
+      #
+      # return the ListItem objects that are children of the
+      # UnOrderedList
+      #
+      def list_items
+        children.collect do |obj|
+          Druid::Elements::ListItem.new(obj)
+        end
+      end
+
       protected
 
       def child_xpath
-        ".//child::li"
+        "./child::li"
       end
 
       private
 
       def children
-        list_items.find_all { |item| item.parent == element}
-      end
-
-      def list_items
         element.uls(:xpath => child_xpath)
       end
     end

data/lib/druid/elements/video.rb

@@ -2,15 +2,6 @@ module Druid
   module Elements
     class Video < Media
 
-      def height
-        height = attribute(:height)
-        return height.to_i if height
-      end
-
-      def width
-        width = attribute(:width)
-        return width.to_i if width
-      end
     end
     Druid::Elements.type_to_class[:video] = Druid::Elements::Video
   end

data/lib/druid/locator_generator.rb

@@ -3,71 +3,116 @@ module Druid
 
     BASIC_ELEMENTS = [:abbr,
                       :address,
+                      :animate,
+                      :animate_motion,
+                      :animate_transform,
                       :article,
                       :as,
                       :aside,
+                      :base,
                       :bdi,
                       :bdo,
                       :blockquote,
                       :body,
                       :br,
                       :caption,
+                      :circle,
                       :cite,
                       :code,
                       :col,
                       :colgroup,
                       :command,
+                      :cursor,
                       :data,
                       :datalist,
                       :dd,
+                      :defs,
                       :del,
+                      :desc,
                       :details,
                       :dfn,
                       :dialog,
+                      :discard,
                       :dl,
                       :dt,
+                      :ellipse,
                       :em,
                       :embed,
                       :fieldset,
                       :figcaption,
                       :figure,
+                      :foot,
                       :footer,
+                      :foreign_object,
+                      :g,
                       :head,
                       :header,
                       :hgroup,
                       :hr,
+                      :html,
                       :ins,
                       :kbd,
                       :keygen,
                       :legend,
+                      :line,
+                      :linear_gradient,
+                      :main,
                       :map,
                       :mark,
+                      :marker,
                       :menu,
+                      :menuitem,
+                      :mesh_gradient,
+                      :mesh_patch,
+                      :mesh_row,
                       :meta,
+                      :metadata,
                       :meter,
+                      :mpath,
                       :nav,
                       :noscript,
                       :object,
                       :optgroup,
                       :output,
+                      :p,
                       :param,
+                      :path,
+                      :pattern,
+                      :polygon,
+                      :polyline,
                       :pre,
                       :progress,
+                      :q,
+                      :radial_gradient,
+                      :rect,
                       :rp,
                       :rt,
                       :ruby,
+                      :s,
                       :samp,
+                      :script,
                       :section,
                       :small,
+                      :source,
+                      :stop,
                       :strong,
                       :style,
                       :sub,
                       :summary,
                       :sup,
+                      :switch,
+                      :symbol,
+                      :template,
+                      :text_path,
+                      :thread,
                       :time,
                       :title,
                       :track,
+                      :tspan,
+                      :u,
+                      :use,
                       :var,
+                      :view,
                       :wbr]
 
     ADVANCED_ELEMENTS = [:text_field,
@@ -82,6 +127,7 @@ module Druid
                          :span,
                          :table,
                          :cell,
+                         :row,
                          :image,
                          :form,
                          :list_item,
@@ -101,6 +147,7 @@ module Druid
                          :audio,
                          :video,
                          :b,
+                         :i,
                          :svg]
 
     def self.generate_locators(target)

data/lib/druid/section_collection.rb

@@ -0,0 +1,17 @@
+module Druid
+  class SectionCollection < Array
+
+    def find_by values_hash
+      find do |section|
+        values_hash.all? { |key, value| value === section.public_send(key) }
+      end
+    end
+
+    def select_by values_hash
+      matches = select do |section|
+        values_hash.all? { |key, value| value === section.public_send(key) }
+      end
+      self.class[*matches]
+    end
+  end
+end

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module Druid
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/spec/druid/accessors_spec.rb

@@ -205,7 +205,7 @@ describe Druid::Accessors do
 
     it "should raise error when it does not have expected title" do
       expect(driver).to receive(:title).and_return("Not Expected")
-      expect {druid.has_expected_title? }.to raise_error
+      expect {druid.has_expected_title? }.to raise_error "Expected title \'Expected Title\' instead of \'Not Expected\'"
     end
   end
 
@@ -225,6 +225,33 @@ describe Druid::Accessors do
     end
   end
 
+  context "using element accessor" do
+    class DefaultElementTagToElement
+      include Druid
+      # verify that the explicit :element tag can be omitted
+      # element('button', :element, {:css => 'some css'})
+      element('button', { :css => 'some css' })
+      elements('button2', { :css => 'some css' })
+    end
+
+    let(:page) { DefaultElementTagToElement.new(driver) }
+
+    def mock_driver_for(tag)
+      expect(driver).to receive(tag).with(:css => 'some css').and_return(driver)
+    end
+
+    it "should default element tag to element" do
+      mock_driver_for :element
+      page.button_element
+    end
+
+    it "should default elements tag to element" do
+      mock_driver_for :elements
+      expect(driver).to receive(:map).and_return([])
+      page.button2_elements.to_a
+    end
+  end
+
   describe "using default identifiers" do
     class DefaultIdentifier
       include Druid
@@ -699,6 +726,7 @@ describe Druid::Accessors do
     context "when called on a page object" do
       it "should generate accessor methods" do
         expect(druid).to respond_to :logo_element
+        expect(druid).to respond_to :logo_loaded?
       end
 
       it "should call a block on the element method when present " do

data/spec/druid/druid_spec.rb

@@ -70,7 +70,7 @@ describe Druid do
     end
   end
 
-  context "when created with a watir-webdriver browser" do
+  context "when created with a watir browser" do
     it "should include the Druid module" do
       expect(druid).to be_kind_of Druid
     end
@@ -84,6 +84,39 @@ describe Druid do
     end
   end
 
+  context "when sent a missing method" do
+    it "should not respond to it if the @root_element doesn't exist" do
+      expect(nil).to respond_to :to_i
+      expect(druid.instance_variable_get(:@root_element)).to be nil
+      expect(druid).not_to respond_to :to_i
+      expect { druid.to_i }.to raise_error NoMethodError
+    end
+
+    it "should respond to it if the @root_element exists and responds" do
+      expect(druid.instance_variable_get(:@root_element)).to be nil
+      expect(druid).not_to respond_to :bar
+      expect(druid).not_to respond_to :baz
+      class Foo
+        def bar
+          :bar_called
+        end
+
+        private
+
+        def baz
+        end
+      end
+      druid.instance_variable_set(:@root_element, Foo.new)
+
+      expect(druid).to respond_to :bar
+      expect(druid).not_to respond_to :baz
+      expect(druid.bar).to eq :bar_called
+      expect { druid.baz }.to raise_error NoMethodError
+      expect(druid.respond_to?(:baz, true)).to be false
+      expect { druid.send(:baz) }.to raise_error NoMethodError
+    end
+  end
+
   describe "page level functionality" do
     context "when using PageObject" do
 
@@ -114,7 +147,7 @@ describe Druid do
       end
 
       it "should wait until a block returns true" do
-        expect(driver).to receive(:wait_until).with(5, "too long")
+        expect(driver).to receive(:wait_until).with(timeout: 5, message: "too long")
         druid.wait_until(5, "too long")
       end
 
@@ -251,7 +284,7 @@ describe Druid do
 
       it "should use the overriden timeout value when set" do
         Druid.default_page_wait = 10
-        expect(driver).to receive(:wait_until).with(10, nil)
+        expect(driver).to receive(:wait_until).with(timeout: 10, message: nil)
         druid.wait_until
       end
 

data/spec/druid/element_locators_spec.rb

@@ -274,6 +274,28 @@ describe Druid::ElementLocators do
     page.cell_elements
   end
 
+  it "should find a table row" do
+    expect(driver).to receive(:tr).with(:id => 'blah').and_return(driver)
+    element = page.row_element(:id => 'blah')
+    expect(element).to be_instance_of Druid::Elements::TableRow
+  end
+
+  it "should find a table row using a default identifier" do
+    expect(driver).to receive(:tr).with(:index => 0).and_return(driver)
+    page.row_element
+  end
+
+  it "should find all table row" do
+    expect(driver).to receive(:trs).with(:id => 'blah').and_return([driver])
+    elements = page.row_elements(:id => 'blah')
+    expect(elements[0]).to be_instance_of Druid::Elements::TableRow
+  end
+
+  it "should find all table rows using no identifier" do
+    expect(driver).to receive(:trs).with({}).and_return([driver])
+    page.row_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')
@@ -703,4 +725,26 @@ describe Druid::ElementLocators do
     page.b_elements
   end
 
+  it "should find a i element" do
+    expect(driver).to receive(:i).with(:id => 'blah').and_return(driver)
+    element = page.i_element(:id => 'blah')
+    expect(element).to be_instance_of Druid::Elements::Italic
+  end
+
+  it "should find a i element using a default identifier" do
+    expect(driver).to receive(:i).with(:index => 0).and_return(driver)
+    page.i_element
+  end
+
+  it "should find all i elements" do
+    expect(driver).to receive(:is).with(:id => 'blah').and_return([driver])
+    elements = page.i_elements(:id => 'blah')
+    expect(elements[0]).to be_instance_of Druid::Elements::Italic
+  end
+
+  it "should find all b elements using no parameters" do
+    expect(driver).to receive(:is).with({}).and_return([driver])
+    page.i_elements
+  end
+
 end