RubyGems - druid-ts - Versions diffs - 0.0.1 → 1.1.0 - Mend

druid-ts 0.0.1 → 1.1.0

Files changed (145) hide show

checksums.yaml +4 -4
data/.gitignore +5 -0
data/.rspec +1 -0
data/.rvmrc +1 -0
data/.travis.yml +1 -2
data/ChangeLog +218 -0
data/Gemfile +2 -1
data/README.md +64 -7
data/Rakefile +1 -1
data/druid.gemspec +25 -0
data/features/async.feature +18 -0
data/features/button.feature +42 -1
data/features/checkbox.feature +7 -1
data/features/div.feature +6 -0
data/features/element.feature +100 -0
data/features/file_field.feature +35 -0
data/features/form.feature +12 -6
data/features/frames.feature +57 -0
data/features/heading.feature +164 -0
data/features/hidden_field.feature +6 -0
data/features/html/async.html +18 -0
data/features/html/frame_1.html +18 -0
data/features/html/frame_2.html +16 -0
data/features/html/frame_3.html +14 -0
data/features/html/frames.html +12 -0
data/features/html/iframes.html +12 -0
data/features/html/modal.html +17 -0
data/features/html/modal_1.html +38 -0
data/features/html/modal_2.html +27 -0
data/features/html/nested_elements.html +52 -0
data/features/html/nested_frame_1.html +1 -0
data/features/html/nested_frame_2.html +11 -0
data/features/html/nested_frame_3.html +14 -0
data/features/html/nested_frames.html +10 -0
data/features/html/static_elements.html +29 -23
data/features/image.feature +8 -0
data/features/link.feature +5 -0
data/features/list_item.feature +5 -0
data/features/modal_dialog.feature +9 -0
data/features/nested_elements.feature +105 -0
data/features/ordered_list.feature +6 -0
data/features/page_level_actions.feature +48 -0
data/features/paragraph.feature +33 -0
data/features/radio_button.feature +6 -0
data/features/select_list.feature +6 -1
data/features/span.feature +6 -1
data/features/step_definations/async_steps.rb +63 -0
data/features/step_definations/button_steps.rb +25 -1
data/features/step_definations/checkbox_steps.rb +5 -1
data/features/step_definations/div_steps.rb +6 -1
data/features/step_definations/element_steps.rb +55 -1
data/features/step_definations/file_field_steps.rb +27 -0
data/features/step_definations/form_steps.rb +8 -0
data/features/step_definations/frame_steps.rb +112 -0
data/features/step_definations/heading_steps.rb +39 -0
data/features/step_definations/hidden_field_steps.rb +7 -3
data/features/step_definations/image_steps.rb +7 -3
data/features/step_definations/link_steps.rb +8 -3
data/features/step_definations/list_item_steps.rb +9 -1
data/features/step_definations/modal_dialog_steps.rb +38 -0
data/features/step_definations/nested_elements_steps.rb +196 -0
data/features/step_definations/ordered_list_steps.rb +11 -3
data/features/step_definations/page_level_actions_steps.rb +72 -0
data/features/step_definations/paragraph_steps.rb +15 -0
data/features/step_definations/radio_button_steps.rb +5 -1
data/features/step_definations/select_list_steps.rb +10 -2
data/features/step_definations/span_steps.rb +5 -1
data/features/step_definations/table_cell_steps.rb +5 -1
data/features/step_definations/table_steps.rb +17 -3
data/features/step_definations/text_area_steps.rb +18 -2
data/features/step_definations/text_field_steps.rb +9 -1
data/features/step_definations/unordered_list_steps.rb +11 -3
data/features/support/env.rb +0 -15
data/features/support/hooks.rb +7 -0
data/features/support/page.rb +98 -1
data/features/support/persistent_browser.rb +15 -0
data/features/support/url_helper.rb +24 -1
data/features/table.feature +7 -0
data/features/table_cell.feature +6 -0
data/features/text_area.feature +11 -0
data/features/text_field.feature +6 -1
data/features/unordered_list.feature +6 -0
data/lib/druid.rb +251 -3
data/lib/druid/accessors.rb +446 -158
data/lib/druid/assist.rb +394 -0
data/lib/druid/core_ext/string.rb +5 -0
data/lib/druid/element_locators.rb +405 -0
data/lib/druid/elements.rb +28 -0
data/lib/druid/elements/button.rb +6 -1
data/lib/druid/elements/check_box.rb +26 -0
data/lib/druid/elements/div.rb +3 -1
data/lib/druid/elements/element.rb +170 -5
data/lib/druid/elements/file_field.rb +18 -0
data/lib/druid/elements/form.rb +11 -0
data/lib/druid/elements/heading.rb +14 -0
data/lib/druid/elements/hidden_field.rb +12 -2
data/lib/druid/elements/image.rb +13 -0
data/lib/druid/elements/link.rb +2 -0
data/lib/druid/elements/list_item.rb +3 -1
data/lib/druid/elements/option.rb +9 -0
data/lib/druid/elements/ordered_list.rb +4 -5
data/lib/druid/elements/paragraph.rb +9 -0
data/lib/druid/elements/radio_button.rb +25 -0
data/lib/druid/elements/select_list.rb +10 -1
data/lib/druid/elements/span.rb +3 -1
data/lib/druid/elements/table.rb +20 -1
data/lib/druid/elements/table_cell.rb +7 -0
data/lib/druid/elements/table_row.rb +5 -1
data/lib/druid/elements/text_area.rb +15 -1
data/lib/druid/elements/text_field.rb +11 -1
data/lib/druid/elements/unordered_list.rb +5 -5
data/lib/druid/nested_elements.rb +103 -0
data/lib/druid/page_factory.rb +4 -4
data/lib/druid/page_populator.rb +71 -0
data/spec/druid/accessors_spec.rb +789 -0
data/spec/druid/druid_spec.rb +130 -7
data/spec/druid/element_locators_spec.rb +160 -0
data/spec/druid/elements/button_spec.rb +31 -0
data/spec/druid/elements/check_box_spec.rb +38 -0
data/spec/druid/elements/div_spec.rb +19 -0
data/spec/druid/elements/element_spec.rb +150 -0
data/spec/druid/elements/file_field_spec.rb +27 -0
data/spec/druid/elements/form_spec.rb +27 -0
data/spec/druid/elements/heading_spec.rb +39 -0
data/spec/druid/elements/hidden_field_spec.rb +24 -0
data/spec/druid/elements/image_spec.rb +32 -0
data/spec/druid/elements/link_spec.rb +26 -0
data/spec/druid/elements/list_item_spec.rb +19 -0
data/spec/druid/elements/option_spec.rb +10 -0
data/spec/druid/elements/ordered_list_spec.rb +42 -0
data/spec/druid/elements/page_factory_spec.rb +40 -0
data/spec/druid/elements/paragraph_spec.rb +21 -0
data/spec/druid/elements/radio_button_spec.rb +38 -0
data/spec/druid/elements/select_list_spec.rb +37 -0
data/spec/druid/elements/span_spec.rb +19 -0
data/spec/druid/elements/table_cell_spec.rb +23 -0
data/spec/druid/elements/table_row_spec.rb +41 -0
data/spec/druid/elements/table_spec.rb +52 -0
data/spec/druid/elements/text_area_spec.rb +31 -0
data/spec/druid/elements/text_field_spec.rb +31 -0
data/spec/druid/elements/unordered_list_spec.rb +42 -0
data/spec/druid/nested_element_spec.rb +128 -0
data/spec/druid/page_populator_spec.rb +92 -0
data/spec/spec_helper.rb +2 -1
metadata +147 -27

@@ -5,8 +5,8 @@ class TestDruid
 end
 describe Druid do
-  let(:driver){mock_driver}
-  let(:druid){TestDruid.new driver}
+  let(:driver) { mock_driver }
+  let(:druid) { TestDruid.new(driver) }
   context "when created with a watir-webdriver browser" do
     it "should include the Druid module" do
@@ -14,22 +14,145 @@ describe Druid do
     end
   end
+  context "when created with an object we do not understand" do
+    it "should throw an error" do
+      expect {
+        TestDruid.new("blah")
+      }.to raise_error 'expect Watir::Browser'
+    end
+  end
   describe "page level functionality" do
-    context "when using Druid" do
+    context "when using PageObject" do
       it "should display the page text" do
-        expect(druid).to receive(:text).and_return("browser text")
-        expect(druid.text).to eql "browser text"
+        expect(driver).to receive(:text).and_return("driver text")
+        expect(druid.text).to eql "driver text"
       end
       it "should display the html of the page" do
-        expect(druid).to receive(:html).and_return("<html>Some Sample HTML</html>")
+        expect(driver).to receive(:html).and_return("<html>Some Sample HTML</html>")
         expect(druid.html).to eql "<html>Some Sample HTML</html>"
       end
       it "should display the title of the page" do
-        expect(druid).to receive(:title).and_return("I am the title of a page")
+        expect(driver).to receive(:title).and_return("I am the title of a page")
         expect(druid.title).to eql "I am the title of a page"
       end
+      it "should be able to navigate to a page" do
+        expect(driver).to receive(:goto).with("www.baidu.com")
+        druid.navigate_to("www.baidu.com")
+      end
+      it "should know it's current url" do
+        expect(driver).to receive(:url).and_return("www.baidu.com")
+        expect(druid.current_url).to eql "www.baidu.com"
+      end
+      it "should wait until a block returns true" do
+        expect(driver).to receive(:wait_until).with(5, "too long")
+        druid.wait_until(5, "too long")
+      end
+      it "should retrieve the text from alert popup" do
+        allow(driver).to receive_message_chain(:alert, :exists?).and_return(true)
+        allow(driver).to receive_message_chain(:alert, :text).and_return('I am an alert')
+        expect(driver).to receive_message_chain(:alert, :ok)
+        msg = druid.alert do
+        end
+        expect(msg).to eql 'I am an alert'
+      end
+      it "should retrieve the text from confirm popup" do
+        allow(driver).to receive_message_chain(:alert, :exists?).and_return(true)
+        allow(driver).to receive_message_chain(:alert, :text).and_return('I am an confirm')
+        expect(driver).to receive_message_chain(:alert, :ok)
+        msg = druid.confirm(true) do
+        end
+        expect(msg).to eql 'I am an confirm'
+      end
+      it "should retrieve the text from prompt popup" do
+        allow(driver).to receive_message_chain(:alert, :exists?).and_return(true)
+        allow(driver).to receive_message_chain(:alert, :text).and_return('I am an prompt')
+        allow(driver).to receive_message_chain(:alert, :set).with("blah")
+        expect(driver).to receive_message_chain(:alert, :ok)
+        msg = druid.prompt("blah") do
+        end
+        expect(msg).to eql "I am an prompt"
+      end
+      it "should switch to a new window with a given title" do
+        expect(driver).to receive(:window).with(:title => "My Title").and_return(driver)
+        expect(driver).to receive(:use)
+        druid.attach_to_window(:title => "My Title")
+      end
+      it "should switch to a new window with a given index" do
+        expect(driver).to receive(:window).with(:index => 1).and_return(driver)
+        expect(driver).to receive(:use)
+        druid.attach_to_window(:index => 1)
+      end
+      it "should switch to a new window witha given url" do
+        expect(driver).to receive(:window).with(:url => /success\.html/).and_return(driver)
+        expect(driver).to receive(:use)
+        druid.attach_to_window(:url => "success.html")
+      end
+      it "should refresh the page contents" do
+        expect(driver).to receive(:refresh)
+        druid.refresh
+      end
+      it "should know how to go back" do
+        expect(driver).to receive(:back)
+        druid.back
+      end
+      it "should know how to go forward" do
+        expect(driver).to receive(:forward)
+        druid.forward
+      end
+      it "should try a second time after sleeping when attach to window fails" do
+        expect(driver).to receive(:window).once.and_return(driver)
+        expect(driver).to receive(:use).once.and_throw "error"
+        expect(driver).to receive(:window).and_return(driver)
+        expect(driver).to receive(:use)
+        druid.attach_to_window(:value => 'tim')
+      end
+      it "should call intialize_page if it exists" do
+        class CallbackPage
+          include Druid
+          attr_reader :initialize_page
+          def initialize_page
+            @initialize_page = true
+          end
+        end
+        page = CallbackPage.new(driver)
+        expect(page.initialize_page).to be true
+      end
+      it "should convert a modal popup to a window" do
+        expect(driver).to receive(:execute_script)
+        druid.modal_dialog {}
+      end
+      it "should know how to clear all of the cookies from the browser" do
+        expect(driver).to receive(:clear_cookies)
+        druid.clear_cookies
+      end
+      it "should be able to save a screenshot" do
+        expect(driver).to receive_message_chain(:screenshot,:save)
+        druid.save_screenshot('tim.png')
+      end
     end
   end

data/spec/druid/element_locators_spec.rb ADDED

@@ -0,0 +1,160 @@
+require 'spec_helper'
+class ElementLocatorsTestDruid
+  include Druid
+end
+describe Druid::ElementLocators do
+  let(:driver) { mock_driver }
+  let(:page) { ElementLocatorsTestDruid.new(driver) }
+  it "should find a button element" do
+    expect(driver).to receive(:button).with(:id => 'blah').and_return(driver)
+    button = page.button_element(:id => 'blah')
+    expect(button).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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 a file field element" do
+    expect(driver).to receive(:file_field).with(:id => 'blah').and_return(driver)
+    element = page.file_field_element(:id => 'blah')
+    expect(element).to be_instance_of Druid::Elements::FileField
+  end
+end

data/spec/druid/elements/button_spec.rb ADDED

@@ -0,0 +1,31 @@
+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].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
+      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 ADDED

@@ -0,0 +1,38 @@
+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) }
+    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
+  end
+end

data/spec/druid/elements/div_spec.rb ADDED

@@ -0,0 +1,19 @@
+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].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
+    end
+  end
+end

data/spec/druid/elements/element_spec.rb ADDED

@@ -0,0 +1,150 @@
+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 "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)
+      expect(element.visible?).to be true
+    end
+    it "should know when it is not visible" do
+      expect(we).to receive(:visible?).and_return(false)
+      expect(element.visible?).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 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 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 be able to block until it is present" do
+      expect(we).to receive(:wait_until_present).with(10)
+      element.when_present(10)
+    end
+    it "should return the element when it is present" do
+      expect(we).to receive(:wait_until_present).with(10)
+      expect(element.when_present(10)).to eq element
+    end
+    it "should be able to block until it is visible" do
+      expect(Watir::Wait).to receive(:until).with(10, "Element was not visible in 10 seconds")
+      element.when_visible(10)
+    end
+    it "should return the element when it is visible" do
+      expect(Watir::Wait).to receive(:until).with(10, "Element was 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
+      expect(Watir::Wait).to receive(:while).with(10, "Element still visible after 10 seconds")
+      element.when_not_visible(10)
+    end
+    it "should return the element when it is not visible" do
+      expect(Watir::Wait).to receive(:while).with(10, "Element still visible after 10 seconds")
+      expect(element.when_not_visible(10)).to eq element
+    end
+    it "should be able to block until a user define event fires true" do
+      expect(Watir::Wait).to receive(:until).with(10, "Element blah")
+      element.wait_until(10, "Element blah") {}
+    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 inspect element" do
+      expect(we).to receive(:inspect)
+      element.inspect
+    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
+  end
+end