druid-s 1.0.0

data/spec/druid/elements/bold_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Bold do
+  let(:bold) { Druid::Elements::Bold}
+
+  describe "interface" do
+    it "should register with tag :b" do
+      expect(Druid::Elements.element_class_for(:b)).to eql Druid::Elements::Bold
+    end
+  end
+end

data/spec/druid/elements/button_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Button do
+
+  describe "interface" do
+    it "should register with type :submit" do
+      expect(Druid::Elements.element_class_for(:input, :submit)).to be Druid::Elements::Button
+    end
+
+    it "should register with type :image" do
+      expect(Druid::Elements.element_class_for(:input, :image)).to be Druid::Elements::Button
+    end
+
+    it "should register with type :button" do
+      expect(Druid::Elements.element_class_for(:input, :button)).to be Druid::Elements::Button
+    end
+
+    it "should register with type :reset" do
+      expect(Druid::Elements.element_class_for(:input, :reset)).to be Druid::Elements::Button
+    end
+  end
+end

data/spec/druid/elements/check_box_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::CheckBox do
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:checkbox) { Druid::Elements::CheckBox.new(element) }
+
+    it "should register with type :checkbox" do
+      expect(Druid::Elements.element_class_for(:input, :checkbox)).to be Druid::Elements::CheckBox
+    end
+
+  end
+end

data/spec/druid/elements/div_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Div do
+  describe "interface" do
+    it "should register with tag :div" do
+      expect(Druid::Elements.element_class_for(:div)).to be Druid::Elements::Div
+    end
+  end
+end

data/spec/druid/elements/element_spec.rb

@@ -0,0 +1,250 @@
+require 'druid/elements'
+
+describe Druid::Elements::Element do
+  let(:we) { double('we') }
+  let(:element) { Druid::Elements::Element.new(we) }
+
+  context "when handling unknown requests" do
+    it "should delegate to the driver element" do
+      expect(we).to receive(:do_this)
+      element.do_this
+    end
+  end
+
+  context "on a druid" do
+    it "should know when it is visible" do
+      expect(we).to receive(:present?).and_return(true)
+      expect(element.present?).to be true
+    end
+
+    it "should know when it is not visible" do
+      expect(we).to receive(:present?).and_return(false)
+      expect(element.present?).to be false
+    end
+
+    it "should know when it exists" do
+      expect(we).to receive(:exist?).and_return(true)
+      expect(element.exist?).to be true
+    end
+
+    it "should know when it does not exist" do
+      expect(we).to receive(:exist?).and_return(false)
+      expect(element.exist?).to be false
+    end
+
+    it "should be able to return the text contained in the element" do
+      expect(we).to receive(:text).and_return("my text")
+      expect(element.text).to eql "my text"
+    end
+
+    it "should know when it is not equal to another" do
+      expect(element).not_to eq 'not an element'
+    end
+
+    it "should know when it is equal to another" do
+      expect(we).to receive(:==).and_return(true)
+      expect(element == element).to be true
+    end
+
+    it "should return its tag name" do
+      expect(we).to receive(:tag_name).and_return('h1')
+      expect(element.tag_name).to eql 'h1'
+    end
+
+    it "should know its value" do
+      expect(we).to receive(:value).and_return('value')
+      expect(element.value).to eql 'value'
+    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(:present?).and_return(false)
+      expect(we).to receive(:present?).and_return(true)
+      expect(element.check_visible).to be true
+    end
+
+    it "should check if the element is present" do
+      # simulate Active Support's Object#present? being included
+      allow_any_instance_of(Object).to receive(:present?)
+
+      expect(we).to receive(:present?)
+      element.present?
+    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
+      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
+      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
+      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")
+      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_while).with(timeout: 10, message: "Element still present in 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
+      allow(we).to receive(:wait_until).with(timeout: 10, message: "Element blah")
+      element.wait_until(10, "Element blah") {true}
+    end
+
+    it "should send keys to the element" do
+      expect(we).to receive(:send_keys).with([:control, 'a'])
+      element.send_keys([:control, 'a'])
+    end
+
+    it "should clear its' contents" do
+      expect(we).to receive(:clear)
+      element.clear
+    end
+
+    it "should be double clickable" do
+      expect(we).to receive(:double_click)
+      element.double_click
+    end
+
+    it "should be right clickable" do
+      expect(we).to receive(:right_click)
+      element.right_click
+    end
+
+    it "should get element's style" do
+      expect(we).to receive(:style).with('class').and_return('tim')
+      expect(element.style('class')).to eql "tim"
+    end
+
+    it "should know if an element is focused" do
+      expect(we).to receive(:focused?).and_return(true)
+      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.focused?).to_not be true
+    end
+
+    it "should be able to fire event" do
+      expect(we).to receive(:fire_event).with('onclick')
+      element.fire_event('onclick')
+    end
+
+    it "should be able to focus element" do
+      expect(we).to receive(:focus)
+      element.focus
+    end
+
+    it "should know if the element is disabled" do
+      expect(we).to receive(:enabled?).and_return(false)
+      expect(element).to be_disabled
+    end
+
+    it "should be able to flash element" do
+      expect(we).to receive(:flash)
+      element.flash
+    end
+
+    it "should return the outer html" do
+      expect(we).to receive(:outer_html).and_return("<div>blah</div>")
+      element.outer_html
+    end
+
+    it "should return the inner html" do
+      expect(we).to receive(:inner_html).and_return("blah")
+      element.inner_html
+    end
+
+    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 }
+
+    before do
+      allow(found).to receive(:tag_name).and_return(:span)
+    end
+
+    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 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 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 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 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 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 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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::FileField do
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:file_field) { Druid::Elements::FileField.new(element) }
+
+    it "should register as type :file" do
+      expect(Druid::Elements.element_class_for(:input, :file)).to be Druid::Elements::FileField
+    end
+  end
+end

data/spec/druid/elements/form_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Form do
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:form) { Druid::Elements::Form.new(element) }
+
+    it "should submit a form" do
+      expect(element).to receive(:submit)
+      form.submit
+    end
+
+    it "should register with tag_name :form" do
+       expect(Druid::Elements.element_class_for(:form)).to be Druid::Elements::Form
+    end
+  end
+end

data/spec/druid/elements/heading_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Heading do
+  describe "interface" do
+    it "should register with tag :h1" do
+      expect(Druid::Elements.element_class_for(:h1)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h2" do
+      expect(Druid::Elements.element_class_for(:h2)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h3" do
+      expect(Druid::Elements.element_class_for(:h3)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h4" do
+      expect(Druid::Elements.element_class_for(:h4)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h5" do
+      expect(Druid::Elements.element_class_for(:h5)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h6" do
+      expect(Druid::Elements.element_class_for(:h6)).to be Druid::Elements::Heading
+    end
+  end
+end

data/spec/druid/elements/hidden_field_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::HiddenField do
+  describe "interface" do
+    it "should register with type :hidden" do
+      expect(Druid::Elements.element_class_for(:input, :hidden)).to be Druid::Elements::HiddenField
+    end
+  end
+end

data/spec/druid/elements/image_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Image do
+  describe "interface" do
+    let(:element) { 'element' }
+    let(:image) { Druid::Elements::Image.new(element) }
+
+    it "should know the image width" do
+      expect(element).to receive(:width).and_return(100)
+      expect(image.width).to eql 100
+    end
+
+    it "should know the image height" do
+      expect(element).to receive(:height).and_return(120)
+      expect(image.height).to eql 120
+    end
+
+    it "should register with tag_name :img" do
+      expect(Druid::Elements.element_class_for(:img)).to be Druid::Elements::Image
+    end
+  end
+end

data/spec/druid/elements/itatic_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Druid::Elements::Italic do
+  let(:italic) { Druid::Elements::Italic}
+  
+  describe "interface" do
+    it "should register with tag :i" do
+      expect(Druid::Elements.element_class_for(:i)).to eql Druid::Elements::Italic
+    end
+  end
+end

data/spec/druid/elements/label_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Label do
+  describe "interface" do
+    it "should register with tag :label" do
+      expect(Druid::Elements.element_class_for(:label)).to be Druid::Elements::Label
+    end
+  end
+end

data/spec/druid/elements/link_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Link do
+  describe "interface" do
+    it "should register with tag :a" do
+      expect(Druid::Elements.element_class_for(:a)).to be Druid::Elements::Link
+    end
+  end
+end

data/spec/druid/elements/list_item_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::ListItem do
+  describe "interface" do
+    it "should register as tag_name :li" do
+      expect(Druid::Elements.element_class_for(:li)).to be Druid::Elements::ListItem
+    end
+  end
+end

data/spec/druid/elements/media_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Druid::Elements::Media do
+  let(:element) { double 'element' }
+  let(:media) { Druid::Elements::Media.new(element) }
+
+  it "should return controls" do
+    expect(media).to receive(:attribute).with(:controls).and_return(true)
+    expect(media.has_controls?).to eq(true)
+  end
+
+end

data/spec/druid/elements/option_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Option do
+  describe "interface" do
+    it "should register as tag_name :option" do
+      expect(Druid::Elements.element_class_for(:option)).to be Druid::Elements::Option
+    end
+  end
+end
+
+describe "interacting with the option" do
+  let(:we) { double 'we' }
+  let(:element) { Druid::Elements::Option.new(we) }
+
+  it "should know if it is selected" do
+    expect(we).to receive(:selected?).and_return true
+    expect(element.selected?).to be true
+  end
+
+end

data/spec/druid/elements/ordered_list_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::OrderedList do
+  let(:ol) { Druid::Elements::OrderedList }
+
+  describe "interface" do
+    let(:ol_element) { double('ol_element').as_null_object }
+    let(:li_element) { double('li_element') }
+
+    it "should register as tag_name :ol" do
+      expect(Druid::Elements.element_class_for(:ol)).to be Druid::Elements::OrderedList
+    end
+
+    context "for sub methods" do
+      before(:each) do
+        allow(ol_element).to receive(:tag_name).and_return(:ol)
+      end
+      let(:ol) {  ol = Druid::Elements::OrderedList.new(ol_element) }
+
+      it "should return a list item when indexed" do
+        allow(ol_element).to receive(:children).and_return([ol_element, ol_element])
+        ol[1]
+      end
+
+      it "should know how many list items it contains" do
+        allow(ol_element).to receive(:children).and_return([ol_element])
+        expect(ol.items).to eql 1
+      end
+
+      it "should iterate over the list items" do
+        expect(ol).to receive(:list_items).and_return(Array.new(5, ol_element))
+        expect(ol.items).to eql 5
+      end
+    end
+
+  end
+end

data/spec/druid/elements/page_factory_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'druid/page_factory'
+
+class FactoryTestDruid
+  include Druid
+  page_url "http://www.baidu.com"
+end
+
+class TestWorldOne
+  include Druid::PageFactory
+
+  attr_accessor :driver
+end
+
+describe Druid::PageFactory do
+  before(:each) do
+    @world = TestWorldOne.new
+    @world.driver = mock_driver
+  end
+
+  it "should create and visit a new page" do
+    expect(@world.driver).to receive(:goto)
+    @world.visit_page FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+  end
+
+  it "should create a new page object and execute a block" do
+    expect(@world.driver).not_to receive(:goto)
+    @world.on_page FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+  end
+
+  it "should set an instance variable that can be used outside of the block" do
+    page = @world.on_page FactoryTestDruid
+    current_page = @world.instance_variable_get "@current_page"
+    expect(current_page).to eq page
+  end
+end

data/spec/druid/elements/paragraph_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Paragraph do
+  let(:paragraph) { Druid::Elements::Paragraph }
+
+  describe "interface" do
+    it "should register with type :checkbox" do
+      expect(Druid::Elements.element_class_for(:p)).to be Druid::Elements::Paragraph
+    end
+  end
+end

data/spec/druid/elements/radio_button_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::RadioButton do
+  describe "interface" do
+    let(:element) { double("element") }
+    let(:driver) { double("driver") }
+    let(:radio) { Druid::Elements::RadioButton.new(element)}
+
+    it "should register as type :radio" do
+      expect(Druid::Elements.element_class_for(:input, :radio)).to be Druid::Elements::RadioButton
+    end
+  end
+end

data/spec/druid/elements/select_list_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::SelectList do
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:opts) { [element, element] }
+    let(:select_list) { Druid::Elements::SelectList.new(element) }
+
+    it "should return an option when indexed" do
+      expect(element).to receive(:options).with(no_args).and_return(opts)
+      expect(select_list[1]).to be_instance_of Druid::Elements::Option
+    end
+
+    it "should retrieve all values of select_list" do
+      expect(element).to receive(:options).with(no_args).and_return(opts)
+      expect(select_list.options.size).to eql 2
+    end
+
+    it "should select an element" do
+      expect(element).to receive(:select).with('test')
+      select_list.select('test')
+    end
+
+    it "should register with tag_name :select" do
+      expect(Druid::Elements.element_class_for(:select)).to be Druid::Elements::SelectList
+    end
+
+    it "should return an array of selected options" do
+      allow(element).to receive(:selected_options).and_return(opts)
+      allow(element).to receive(:text).and_return(element)
+      expect(select_list.selected_options).to eql opts
+    end
+
+    it "should be able to get the value for the selected options" do
+      allow(element).to receive(:selected_options).and_return(opts)
+      allow(element).to receive(:value).and_return(element)
+      expect(select_list.selected_values).to eql opts
+    end
+
+    it "should know if it includes some value" do
+      expect(element).to receive(:include?).with('blah').and_return(true)
+      select_list.include?('blah')
+    end
+
+    it "should know if an option is selected" do
+      expect(element).to receive(:selected?).with("blah").and_return(true)
+      select_list.selected?('blah')
+    end
+  end
+end

data/spec/druid/elements/span_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Span do
+  describe "interface" do
+    it "should register with tag_name :span" do
+      expect(Druid::Elements.element_class_for(:span)).to be Druid::Elements::Span
+    end
+  end
+end