druid-ts 1.2.4 → 1.2.5

data/lib/druid/page_populator.rb

@@ -23,74 +23,81 @@ module Druid
     #   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
+    # @param data [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_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)
+        populate_section(key, value) if value.is_a?(Hash)
+        populate_value(self, key, value)
       end
     end
 
     private
 
-    def populate_text(key, value)
-      self.send "#{key}=", value
+    def populate_section(section, data)
+      return unless self.respond_to? section
+      data.each do |key, value|
+        populate_value(self.send(section), key, value)
+      end
     end
 
-    def populate_checkbox(key, value)
-      return self.send "check_#{key}" if value
-      return self.send "uncheck_#{key}"
+    def populate_value(receiver, key, value)
+      populate_checkbox(receiver, key, value) if is_checkbox?(receiver, key) and is_enabled?(receiver, key)
+      populate_radiobuttongroup(receiver, key, value) if is_radiobuttongroup?(receiver, key)
+      populate_radiobutton(receiver, key, value) if is_radiobutton?(receiver, key) and is_enabled?(receiver, key)
+      populate_select_list(receiver, key, value) if is_select_list?(receiver, key)
+      populate_text(receiver, key, value) if is_text?(receiver, key) and is_enabled?(receiver, key)
     end
 
-    def populate_radiobutton(key, value)
-      return self.send "select_#{key}" if value
+    def populate_text(receiver, key, value)
+      receiver.send "#{key}=", value
     end
 
-    def populate_radiobuttongroup(key, value)
-      return self.send "select_#{key}", value
+    def populate_checkbox(receiver, key, value)
+      return receiver.send "check_#{key}" if value
+      return receiver.send "uncheck_#{key}"
     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
+    def populate_radiobutton(receiver, key, value)
+      return receiver.send "select_#{key}" if value
+    end
+
+    def populate_radiobuttongroup(receiver, key, value)
+      return receiver.send "select_#{key}", value
+    end
+
+    def populate_select_list(receiver, key, value)
+      receiver.send "#{key}=", value
     end
 
-    def is_text?(key)
-      return false if is_select_list?(key)
-      respond_to?("#{key}=".to_sym)
+    def is_text?(receiver, key)
+      return false if is_select_list?(receiver, key)
+      receiver.respond_to?("#{key}=".to_sym)
     end
 
-    def is_checkbox?(key)
-      respond_to?("check_#{key}".to_sym)
+    def is_checkbox?(receiver, key)
+      receiver.respond_to?("check_#{key}".to_sym)
     end
 
-    def is_radiobutton?(key)
-      respond_to?("select_#{key}".to_sym)
+    def is_radiobutton?(receiver, key)
+      receiver.respond_to?("select_#{key}".to_sym)
     end
 
-    def is_radiobuttongroup?(key)
-      respond_to?("select_#{key}".to_sym) and respond_to?("#{key}_values")
+    def is_radiobuttongroup?(receiver, key)
+      receiver.respond_to?("select_#{key}".to_sym) and receiver.respond_to?("#{key}_values")
     end
 
-    def is_select_list?(key)
-      respond_to?("#{key}_options".to_sym)
+    def is_select_list?(receiver, key)
+      receiver.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"
-      element = self.send("#{key}_element")
+    def is_enabled?(receiver, key)
+      return false if is_radiobuttongroup?(receiver, key)
+      return true if (receiver.send "#{key}_element").tag_name == "textarea"
+      element = receiver.send("#{key}_element")
       element.enabled? and element.visible?
     end
   end

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module Druid
-  VERSION = "1.2.4"
+  VERSION = "1.2.5"
 end

data/spec/druid/accessors_spec.rb

@@ -509,9 +509,9 @@ describe Druid::Accessors do
 
     context "implementation" do
       it "should get the current item from a select list" do
-        allow(driver).to receive(:selected?).and_return(driver)
-        allow(driver).to receive(:text).and_return('OH')
-        expect(driver).to receive_message_chain(:select_list, :options).and_return([driver])
+        expect(driver).to receive(:select_list).and_return(driver)
+        expect(driver).to receive(:selected_options).and_return [driver]
+        expect(driver).to receive(:text).and_return('OH')
         expect(druid.state).to eql 'OH'
       end
 

data/spec/druid/elements/check_box_spec.rb

@@ -6,21 +6,6 @@ describe Druid::Elements::CheckBox do
     let(:element) { double 'element' }
     let(:checkbox) { Druid::Elements::CheckBox.new(element) }
 
-    it "should check" do
-      expect(element).to receive(:set)
-      checkbox.check
-    end
-
-    it "should uncheck" do
-      expect(element).to receive(:clear)
-      checkbox.uncheck
-    end
-
-    it "should know if it is checked" do
-      expect(element).to receive(:set?)
-      checkbox.checked?
-    end
-
     it "should register with type :checkbox" do
       expect(Druid::Elements.element_class_for(:input, :checkbox)).to be Druid::Elements::CheckBox
     end

data/spec/druid/elements/element_spec.rb

@@ -56,52 +56,57 @@ describe Druid::Elements::Element do
       expect(element.value).to eql 'value'
     end
 
-    it "should know how to retrieve the value of an attribute" do
-      expect(we).to receive(:attribute_value).with('class').and_return('tim')
-      expect(element.attribute('class')).to eql 'tim'
-    end
-
     it "should be clickable" do
       expect(we).to receive(:click)
       element.click
     end
 
+    it "should check if the element is visible" do
+      expect(we).to receive(:visible?).and_return(false)
+      expect(we).to receive(:visible?).and_return(true)
+      expect(element.check_visible).to be true
+    end
+
+    it "should check if the element exists" do
+      expect(we).to receive(:exists?).and_return(false)
+      expect(we).to receive(:exists?).and_return(true)
+      expect(element.check_exist).to be true
+    end
+
     it "should be able to block until it is present" do
-      expect(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
       element.when_present(10)
     end
 
     it "should return the element when it is present" do
-      expect(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
-      expect(element.when_present(10)).to eq element
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element not present in 10 seconds")
+      new_element = element.when_present(10)
+      expect(new_element).to eql element
     end
 
     it "should use the overriden wait when set" do
       Druid.default_element_wait = 20
-      expect(we).to receive(:wait_until).with(timeout: 20, message: "Element not present in 20 seconds")
+      allow(we).to receive(:wait_until).with(timeout: 20, message: "Element not present in 20 seconds")
       element.when_present
     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
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element not visible in 10 seconds")
+      allow(we).to receive(:displayed?).and_return(true)
+      new_element = element.when_visible(10)
+      expect(new_element).to eql 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")
+      allow(we).to receive(:wait_while).with(timeout: 10, message: "Element still visible after 10 seconds")
+      allow(we).to receive(:displayed?).and_return(false)
       element.when_not_visible(10)
     end
 
     it "should be able to block until a user define event fires true" do
-      expect(we).to receive(:wait_until).with(timeout: 10, message: "Element blah")
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element blah")
       element.wait_until(10, "Element blah") {true}
     end
 
@@ -150,18 +155,6 @@ describe Druid::Elements::Element do
       element.focus
     end
 
-    it "should check if the element is visible" do
-      expect(we).to receive(:visible?).and_return(false)
-      expect(we).to receive(:visible?).and_return(true)
-      expect(element.check_visible).to be true
-    end
-
-    it "should check if the element exists" do
-      expect(we).to receive(:exist?).and_return(false)
-      expect(we).to receive(:exist?).and_return(true)
-      expect(element.check_exist).to be true
-    end
-
     it "should know if the element is disabled" do
       expect(we).to receive(:enabled?).and_return(false)
       expect(element).to be_disabled
@@ -172,74 +165,80 @@ describe Druid::Elements::Element do
       element.flash
     end
 
-    it "should scroll into view" do
-      expect(we).to receive(:wd).and_return(we)
-      expect(we).to receive(:location_once_scrolled_into_view)
-      element.scroll_into_view
+    it "should return the outer html" do
+      expect(we).to receive(:outer_html).and_return("<div>blah</div>")
+      element.outer_html
     end
 
-    it "should know its location" do
-      expect(we).to receive(:wd).and_return(we)
-      expect(we).to receive(:location)
-      element.location
+    it "should return the inner html" do
+      expect(we).to receive(:inner_html).and_return("blah")
+      element.inner_html
     end
 
-    it "should know its size" do
-      expect(we).to receive(:wd).and_return(we)
-      expect(we).to receive(:size)
-      element.size
+    it "should know if it is stale" do
+      expect(we).to receive(:stale?).and_return(false)
+      expect(element.stale?).to be false
     end
+  end
 
+  context 'walking the dom' do
+    let(:found) { double('found').as_null_object }
 
-    it "should have a height" do
-      expect(we).to receive(:wd).and_return(we)
-      expect(we).to receive(:size).and_return({'width' => 30, 'height' => 20})
-      expect(element.height).to eql 20
+    before do
+      allow(found).to receive(:tag_name).and_return(:span)
     end
 
-    it "should have a width" do
-      expect(we).to receive(:wd).and_return(we)
-      expect(we).to receive(:size).and_return({'width' => 30, 'height' => 20})
-      expect(element.width).to eql 30
+    it 'should find the parent object' do
+      expect(we).to receive(:parent).and_return(found)
+      object = element.parent
+      expect(object).to be_a(Druid::Elements::Span)
+      expect(object.tag_name).to eql :span
     end
 
-    it "should have a centre" do
-      allow(we).to receive(:wd).and_return(we)
-      allow(we).to receive(:location).and_return({'y' => 80, 'x' => 40})
-      allow(we).to receive(:size).and_return({'width' => 30, 'height' => 20})
-      expect(element.centre).to include(
-        'y' => 90,
-        'x' => 55
-      )
+    it 'should find the proceeding sibling' do
+      expect(we).to receive(:preceding_sibling).and_return(found)
+      object = element.preceding_sibling
+      expect(object).to be_a(Druid::Elements::Span)
+      expect(object.tag_name).to eql :span
     end
 
-    it "should have a centre greater than y position" do
-      allow(we).to receive(:wd).and_return(we)
-      allow(we).to receive(:location).and_return({'y' => 80, 'x' => 40})
-      allow(we).to receive(:size).and_return({'width' => 30, 'height' => 20})
-      expect(element.centre['y']).to be > element.location['y']
+    it 'should find the following sibling' do
+      expect(we).to receive(:following_sibling).and_return(found)
+      object = element.following_sibling
+      expect(object).to be_a(Druid::Elements::Span)
+      expect(object.tag_name).to eql :span
     end
 
-    it "should have a centre greater than x position" do
-      allow(we).to receive(:wd).and_return(we)
-      allow(we).to receive(:location).and_return({'y' => 80, 'x' => 40})
-      allow(we).to receive(:size).and_return({'width' => 30, 'height' => 20})
-      expect(element.centre['x']).to be > element.location['x']
+    it 'should find all of its siblings' do
+      expect(we).to receive(:siblings).and_return([found, found])
+      results = element.siblings
+      expect(results.size).to eql 2
+      expect(results[0]).to be_a(Druid::Elements::Span)
+      expect(results[1]).to be_a(Druid::Elements::Span)
     end
 
-    it "should return the outer html" do
-      expect(we).to receive(:outer_html).and_return("<div>blah</div>")
-      element.outer_html
+    it 'should find all of its children' do
+      expect(we).to receive(:children).and_return([found, found])
+      results = element.children
+      expect(results.size).to eql 2
+      expect(results[0]).to be_a(Druid::Elements::Span)
+      expect(results[1]).to be_a(Druid::Elements::Span)
     end
 
-    it "should return the inner html" do
-      expect(we).to receive(:inner_html).and_return("blah")
-      element.inner_html
+    it 'should find all of the preceding siblings' do
+      expect(we).to receive(:preceding_siblings).and_return([found, found])
+      results = element.preceding_siblings
+      expect(results.size).to eql 2
+      expect(results[0]).to be_a(Druid::Elements::Span)
+      expect(results[1]).to be_a(Druid::Elements::Span)
     end
 
-    it "should know if it is stale" do
-      expect(we).to receive(:stale?).and_return(false)
-      expect(element.stale?).to be false
+    it 'should find all of the following siblings' do
+      expect(we).to receive(:following_siblings).and_return([found, found])
+      results = element.following_siblings
+      expect(results.size).to eql 2
+      expect(results[0]).to be_a(Druid::Elements::Span)
+      expect(results[1]).to be_a(Druid::Elements::Span)
     end
   end
 end

data/spec/druid/elements/file_field_spec.rb

@@ -6,11 +6,6 @@ describe Druid::Elements::FileField do
     let(:element) { double 'element' }
     let(:file_field) { Druid::Elements::FileField.new(element) }
 
-    it "should set its' value" do
-      expect(element).to receive(:set).with('a file')
-      file_field.value = 'a file'
-    end
-
     it "should register as type :file" do
       expect(Druid::Elements.element_class_for(:input, :file)).to be Druid::Elements::FileField
     end

data/spec/druid/elements/media_spec.rb

@@ -4,58 +4,9 @@ describe Druid::Elements::Media do
   let(:element) { double 'element' }
   let(:media) { Druid::Elements::Media.new(element) }
 
-  it "should return autoplay" do
-    expect(media).to receive(:attribute).with(:autoplay).and_return(true)
-    expect(media.autoplay?).to eq(true)
-  end
-
   it "should return controls" do
     expect(media).to receive(:attribute).with(:controls).and_return(true)
     expect(media.has_controls?).to eq(true)
   end
 
-  it "should return paused" do
-    expect(media).to receive(:attribute).with(:paused).and_return(true)
-    expect(media.paused?).to eq(true)
-  end
-
-  it "should not return duration when not present" do
-    expect(media).to receive(:attribute).with(:duration).and_return(nil)
-    expect(media.duration).to eq(nil)
-  end
-
-  it "should return duration when present" do
-    expect(media).to receive(:attribute).with(:duration).and_return('1.405')
-    expect(media.duration).to eq(1.405)
-  end
-
-  it "should not return volume when not present" do
-    expect(media).to receive(:attribute).with(:volume).and_return(nil)
-    expect(media.volume).to eq(nil)
-  end
-
-  it "should return volume when present" do
-    expect(media).to receive(:attribute).with(:volume).and_return('3')
-    expect(media.volume).to eq(3)
-  end
-
-  it "should return ended" do
-    expect(media).to receive(:attribute).with(:ended).and_return(true)
-    expect(media.ended?).to eq(true)
-  end
-
-  it "should return seeking" do
-    expect(media).to receive(:attribute).with(:seeking).and_return(true)
-    expect(media.seeking?).to eq(true)
-  end
-
-  it "should return loop" do
-    expect(media).to receive(:attribute).with(:loop).and_return(true)
-    expect(media.loop?).to eq(true)
-  end
-
-  it "should return muted" do
-    expect(media).to receive(:attribute).with(:muted).and_return(true)
-    expect(media.muted?).to eq(true)
-  end
 end