druid-ts 1.2.2 → 1.2.3

data/lib/druid/elements/link.rb

@@ -2,22 +2,6 @@ module Druid
   module Elements
     class Link < Element
 
-      #
-      # return the href fot the link
-      #
-      def href
-        element.href
-      end
-
-      protected
-
-      def self.finders
-         super + [:href, :text, :css, :title]
-      end
-
-      def self.mapping
-         super.merge({:link => :text, :link_text => :text})
-      end
     end
 
     Druid::Elements.tag_to_class[:a] = Druid::Elements::Link

data/lib/druid/elements/list_item.rb

@@ -2,10 +2,6 @@ module Druid
   module Elements
     class ListItem < Element
 
-      def self.finders
-        super + [:text]
-      end
-
     end
 
     Druid::Elements.tag_to_class[:li] = Druid::Elements::ListItem

data/lib/druid/elements/option.rb

@@ -2,12 +2,6 @@ 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

@@ -3,10 +3,6 @@ module Druid
     class OrderedList < Element
       attr_accessor :li_element
 
-      def self.finders
-        [:class, :id, :index, :xpath]
-      end
-
       def [](idx)
         Druid::Elements::ListItem.new(children[idx])
       end

data/lib/druid/elements/radio_button.rb

@@ -2,9 +2,6 @@ module Druid
   module Elements
     class RadioButton < Element
 
-      def self.finders
-        super + [:value, :label]
-      end
       #
       # Select the RadioButton
       #

data/lib/druid/elements/select_list.rb

@@ -2,10 +2,6 @@ module Druid
   module Elements
     class SelectList < Element
 
-      def self.finders
-        super + [:value, :text, :label]
-      end
-
       def [](idx)
         options[idx]
       end
@@ -14,21 +10,6 @@ module Druid
         element.options.map { |e| Druid::Elements::Option.new(e)}
       end
 
-      #
-      # Select a value from the list
-      #
-      def select(value)
-        element.select(value)
-      end
-
-      #
-      # Select the options whose value attribute matches the Given
-      # string
-      #
-      def select_value(value)
-        element.select_value(value)
-      end
-
       #
       # @return [Array<String>] An array of strings representing the text of the currently selected options.
       #
@@ -51,13 +32,6 @@ module Druid
         element.include? value
       end
 
-      #
-      # Returns true if any of the selected options' text or label match the given value.
-      # @param [String, Regexp] value A value
-      # @return [Boolean]
-      def selected? value
-        element.selected? value
-      end
     end
 
     Druid::Elements.tag_to_class[:select] = Druid::Elements::SelectList

data/lib/druid/elements/span.rb

@@ -2,10 +2,6 @@ module Druid
   module Elements
     class Span < Element
 
-      def self.finders
-        [:class, :id, :index, :xpath, :text, :title]
-      end
-
     end
 
     Druid::Elements.tag_to_class[:span] = Druid::Elements::Span

data/lib/druid/elements/table_cell.rb

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

data/lib/druid/elements/table_row.rb

@@ -1,3 +1,4 @@
+require 'watir/elements/html_elements'
 module Druid
   module Elements
     class TableRow < Element
@@ -30,6 +31,9 @@ module Druid
       def find_index_by_title(title)
         table = element.parent
         table = table.parent if table.tag_name == 'tbody'
+        if table.instance_of? Watir::HTMLElement
+          table = table.to_subtype
+        end
         first_row = table[0]
         first_row.cells.find_index { |column| column.text.include? title}
       end

data/lib/druid/elements/text_area.rb

@@ -2,9 +2,6 @@ module Druid
   module Elements
     class TextArea < Element
 
-      def self.finders
-        super + [:label]
-      end
       #
       # Set the value of the TextArea
       #
@@ -12,20 +9,6 @@ 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

@@ -2,10 +2,6 @@ module Druid
   module Elements
     class TextField < Element
 
-      def self.finders
-        super + [:text, :title, :label]
-      end
-
       #
       # Set the value of the TextField
       #
@@ -13,9 +9,6 @@ module Druid
         element.set(new_value)
       end
 
-      def append text
-        element.append text
-      end
     end
 
     Druid::Elements.type_to_class[:text] = Druid::Elements::TextField

data/lib/druid/elements/unordered_list.rb

@@ -2,10 +2,6 @@ module Druid
   module Elements
     class UnOrderedList < Element
 
-      def self.finders
-        [:class, :id, :index, :xpath]
-      end
-
       def [](idx)
         Druid::Elements::ListItem.new(children[idx])
       end

data/lib/druid/page_populator.rb

@@ -33,6 +33,7 @@ module Druid
         populate_checkbox(key, value) if is_checkbox?(key) and is_enabled?(key)
         populate_radiobuttongroup(key, value) if is_radiobuttongroup?(key)
         populate_radiobutton(key, value) if is_radiobutton?(key) and is_enabled?(key)
+        populate_select_list(key, value) if is_select_list?(key)
         populate_text(key, value) if is_text?(key) and is_enabled?(key)
       end
     end
@@ -56,7 +57,17 @@ module Druid
       return self.send "select_#{key}", value
     end
 
+    def populate_select_list(key, value)
+      select_element = self.send("#{key}_element")
+      if select_element.options.include?(value)
+        select_element.select(value)
+      else
+        select_element.select_value(value)
+      end
+    end
+
     def is_text?(key)
+      return false if is_select_list?(key)
       respond_to?("#{key}=".to_sym)
     end
 
@@ -72,6 +83,10 @@ module Druid
       respond_to?("select_#{key}".to_sym) and respond_to?("#{key}_values")
     end
 
+    def is_select_list?(key)
+      respond_to?("#{key}_options".to_sym)
+    end
+
     def is_enabled?(key)
       return false if is_radiobuttongroup?(key)
       return true if (self.send "#{key}_element").tag_name == "textarea"

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module Druid
-  VERSION = "1.2.2"
+  VERSION = "1.2.3"
 end

data/spec/druid/druid_spec.rb

@@ -85,35 +85,15 @@ describe Druid do
   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
+      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
 

data/spec/druid/elements/area_spec.rb

@@ -2,14 +2,6 @@ require 'spec_helper'
 require 'druid/elements'
 
 describe Druid::Elements::Area do
-  context "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :name, :xpath].each do |t|
-        identifier = Druid::Elements::Area.identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-  end
 
   context "implementation" do
     let(:element) { double('element') }

data/spec/druid/elements/bold_spec.rb

@@ -4,15 +4,6 @@ require 'druid/elements'
 describe Druid::Elements::Bold do
   let(:bold) { Druid::Elements::Bold}
 
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :idenx, :name, :xpath, :css].each do |t|
-        identifier = bold.identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-  end
-
   describe "interface" do
     it "should register with tag :b" do
       expect(Druid::Elements.element_class_for(:b)).to eql Druid::Elements::Bold

data/spec/druid/elements/button_spec.rb

@@ -2,14 +2,6 @@ require 'spec_helper'
 require 'druid/elements'
 
 describe Druid::Elements::Button do
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :name, :value, :xpath, :src, :alt, :css].each do |t|
-        identifier = Druid::Elements::Button.identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-  end
 
   describe "interface" do
     it "should register with type :submit" do

data/spec/druid/elements/canvas_spec.rb

@@ -2,15 +2,6 @@ require 'spec_helper'
 require 'druid/elements'
 
 describe Druid::Elements::Canvas do
-  context "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :name, :xpath].each do |t|
-        identifier = Druid::Elements::Canvas.identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-  end
-
   context "implementation" do
     let(:element) { double('canvas_element') }
     let(:canvas) { Druid::Elements::Canvas.new(element) }

data/spec/druid/elements/check_box_spec.rb

@@ -2,15 +2,6 @@ require 'spec_helper'
 require 'druid/elements'
 
 describe Druid::Elements::CheckBox do
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :name, :xpath, :value].each do |t|
-        identifier = Druid::Elements::CheckBox.identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-  end
-
   describe "interface" do
     let(:element) { double 'element' }
     let(:checkbox) { Druid::Elements::CheckBox.new(element) }

data/spec/druid/elements/div_spec.rb

@@ -2,15 +2,6 @@ require 'spec_helper'
 require 'druid/elements'
 
 describe Druid::Elements::Div do
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :text, :index, :xpath, :title].each do |t|
-        identifier = Druid::Elements::Div.identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-  end
-
   describe "interface" do
     it "should register with tag :div" do
       expect(Druid::Elements.element_class_for(:div)).to be Druid::Elements::Div

data/spec/druid/elements/element_spec.rb

@@ -11,16 +11,6 @@ describe Druid::Elements::Element do
     end
   end
 
-  context "when building the identifiers" do
-    it "should build xpath when finding elements by name were not supported" do
-      ['table', 'span', 'div', 'td', 'li', 'ol', 'ul'].each do |tag|
-        how = {:tag_name => tag, :name => 'blah'}
-        result = Druid::Elements::Element.identifier_for how
-        expect(result[:xpath]).to eql ".//#{tag}[@name='blah']"
-      end
-    end
-  end
-
   context "on a druid" do
     it "should know when it is visible" do
       expect(we).to receive(:visible?).and_return(true)
@@ -93,22 +83,25 @@ describe Druid::Elements::Element do
     end
 
     it "should be able to block until it is visible" do
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
       expect(we).to receive(:wait_until).with(timeout: 10, message: "Element not visible in 10 seconds")
       element.when_visible(10)
     end
 
     it "should return the element when it is visible" do
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
       expect(we).to receive(:wait_until).with(timeout: 10, message: "Element not visible in 10 seconds")
       expect(element.when_visible(10)).to eq element
     end
 
     it "should be able to block until it is not visible" do
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
       expect(we).to receive(:wait_while).with(timeout: 10, message: "Element still visible after 10 seconds")
       element.when_not_visible(10)
     end
 
     it "should be able to block until a user define event fires true" do
-      expect(Watir::Wait).to receive(:until).with(timeout: 10, message: "Element blah")
+      expect(we).to receive(:wait_until).with(timeout: 10, message: "Element blah")
       element.wait_until(10, "Element blah") {true}
     end
 
@@ -137,19 +130,14 @@ describe Druid::Elements::Element do
       expect(element.style('class')).to eql "tim"
     end
 
-    it "should inspect element" do
-      expect(we).to receive(:inspect)
-      element.inspect
-    end
-
     it "should know if an element is focused" do
       expect(we).to receive(:focused?).and_return(true)
-      expect(element).to be_focused
+      expect(element.focused?).to be true
     end
 
     it "should know if an element is not focuesd" do
       expect(we).to receive(:focused?).and_return(false)
-      expect(element).to_not be_focused
+      expect(element.focused?).to_not be true
     end
 
     it "should be able to fire event" do