symbiont 0.1.9 → 0.2.0

data/spec/symbiont/web_object_spec.rb

@@ -1,194 +1,194 @@
-require 'spec_helper'
-
-describe "Web Objects" do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { ::Symbiont::WebObjects::WebObject.new(watir_browser) }
-  let(:link) { Symbiont::WebObjects::Link }
-  
-  it "should return no key for an unrecognized locator" do
-    [:invalid].each do |s|
-      locator = link.provide_locator_for s => 'value'
-      locator.keys.first.should == nil
-    end
-  end
-  
-  it "should retrieve the value of an attribute" do
-    watir_browser.should_receive(:attribute_value).and_return(true)
-    watir_definition.attribute("readonly").should be_true
-  end
-  
-  it "should retrieve the style of a web object" do
-    watir_browser.should_receive(:style).with('display').and_return("none")
-    watir_definition.style('display').should == 'none'
-  end
-  
-  it "should retrieve the tag of a web object" do
-    watir_browser.should_receive(:tag_name).and_return("div")
-    watir_definition.tag_name.should == "div"
-  end
-
-  it "should retrieve the html of a web object" do
-    watir_browser.should_receive(:html).and_return("<p>Testing</p>")
-    watir_definition.html.should == "<p>Testing</p>"
-  end
-
-  it "should be able to hover over a web object" do
-    watir_browser.should_receive(:hover).and_return(watir_definition)
-    watir_definition.hover
-  end
-
-  it "should be able to focus on a web object" do
-    watir_browser.should_receive(:focus).and_return(watir_definition)
-    watir_definition.focus
-  end
-
-  it "should be able to fire an event on a web object" do
-    watir_browser.should_receive(:fire_event).and_return("onclick")
-    watir_definition.fire_event("onclick")
-  end
-
-  it "should retrieve the id of a web object" do
-    watir_browser.should_receive(:id).and_return("id")
-    watir_definition.id.should == "id"
-  end
-  
-  it "should retrieve the value of a web object" do
-    watir_browser.should_receive(:value).and_return("value")
-    watir_definition.value.should == "value"
-  end
-  
-  it "should be able to inspect a web object" do
-    watir_browser.should_receive(:inspect).and_return(watir_definition)
-    watir_definition.inspect.should be_instance_of Symbiont::WebObjects::WebObject
-  end
-
-  it "should be able to determine if a web object is equal to another" do
-    watir_browser.should_receive(:==).and_return(true)
-    watir_definition.should == watir_definition
-  end
-
-  it "should be able to flash a web_object" do
-    watir_browser.should_receive(:flash).and_return(watir_definition)
-    watir_definition.flash.should be_instance_of Symbiont::WebObjects::WebObject
-  end
-  
-  it "should determine if a web object is enabled" do
-    watir_browser.should_receive(:enabled?).twice.and_return(true)
-    watir_definition.enabled?.should == true
-    watir_definition.should be_enabled
-  end
-  
-  it "should determine if a web object is disabled" do
-    watir_browser.should_receive(:enabled?).twice.and_return(false)
-    watir_definition.disabled?.should == true
-    watir_definition.should be_disabled
-  end
-  
-  it "should determine if a web object exists" do
-    watir_browser.should_receive(:exists?).and_return(true)
-    watir_definition.exists?.should == true
-  end
-  
-  it "should determine if a web object does not exist" do
-    watir_browser.should_receive(:exists?).and_return(false)
-    watir_definition.exists?.should == false
-  end
-  
-  it "should determine if a web object is visible" do
-    watir_browser.should_receive(:present?).twice.and_return(true)
-    watir_definition.visible?.should == true
-    watir_definition.should be_visible
-  end
-  
-  it "should determine if a web object is not visible" do
-    watir_browser.should_receive(:present?).and_return(false)
-    watir_definition.visible?.should == false
-  end
-  
-  it "should return the text contained by a web object" do
-    watir_browser.should_receive(:text).and_return("testing")
-    watir_definition.text.should == "testing"
-  end
-  
-  it "should simulate a click event on a web object" do
-    watir_browser.should_receive(:click)
-    watir_definition.click
-  end
-
-  it "should simulate a double-click event on a web object" do
-    watir_browser.should_receive(:double_click)
-    watir_definition.double_click
-  end
-
-  it "should allow a clear event on a web object" do
-    watir_browser.should_receive(:clear)
-    watir_definition.clear
-  end
-
-  it "should send key presses to a web object" do
-    watir_browser.should_receive(:send_keys).with([:control, 'a'])
-    watir_definition.send_keys([:control, 'a'])
-  end
-
-  it "should find the parent for a web object" do
-    watir_browser.should_receive(:tag_name).twice.and_return(:p)
-    watir_browser.should_receive(:parent).and_return(watir_definition)
-    watir_definition.parent
-  end
-
-  it "should wait for a web object to be actionable" do
-    watir_browser.should_receive(:wait_until_present).twice.with(5)
-    watir_definition.when_actionable(5)
-    watir_definition.when_present(5)
-  end
-
-  it "should use the provided element wait time for actionable checks" do
-    Symbiont.element_level_wait = 30
-    watir_browser.should_receive(:wait_until_present).with(30)
-    watir_definition.when_present
-  end
-
-  it "should reference a web object when it is actionable" do
-    watir_browser.should_receive(:wait_until_present).with(5)
-    web_object = watir_definition.when_actionable(5)
-    web_object.should === watir_definition
-  end
-
-  it "should wait for a web object to become non-actionable" do
-    watir_browser.should_receive(:wait_while_present).and_return(false)
-    watir_definition.when_not_present(5)
-  end
-
-  it "should wait for a web object to become visible" do
-    watir_browser.should_receive(:present?).and_return(true)
-    watir_definition.when_visible(5)
-  end
-  
-  it "should reference a web object when it is visible" do
-    watir_browser.should_receive(:present?).and_return(true)
-    web_object = watir_definition.when_visible(5)
-    web_object.should === watir_definition
-  end
-  
-  it "should wait for a web object to become invisible" do
-    watir_browser.should_receive(:present?).and_return(false)
-    watir_definition.when_not_visible(5)
-  end
-  
-  it "should reference a web object when it is not visible" do
-    watir_browser.stub(:present?).and_return(false)
-    web_object = watir_definition.when_not_visible(5)
-    web_object.should === watir_definition
-  end
-  
-  it "should wait until a specific condition occurs" do
-    Object::Watir::Wait.stub(:until).with(5, "Condition occurred.")
-    watir_definition.wait_until(5, "Condition occurred.") { true }
-  end
-
-  it "should scroll elements into view" do
-    watir_browser.should_receive(:wd).and_return(watir_browser)
-    watir_browser.should_receive(:location_once_scrolled_into_view)
-    watir_definition.scroll_into_view
-  end
-end
+require 'spec_helper'
+
+describe "Web Objects" do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { ::Symbiont::WebObjects::WebObject.new(watir_browser) }
+  let(:link)             { Symbiont::WebObjects::Link }
+
+  it "should determine if a web object is enabled" do
+    watir_browser.should_receive(:enabled?).twice.and_return(true)
+    watir_definition.enabled?.should == true
+    watir_definition.should be_enabled
+  end
+
+  it "should determine if a web object is disabled" do
+    watir_browser.should_receive(:enabled?).twice.and_return(false)
+    watir_definition.disabled?.should == true
+    watir_definition.should be_disabled
+  end
+
+  it "should determine if a web object is visible" do
+    watir_browser.should_receive(:present?).twice.and_return(true)
+    watir_definition.visible?.should == true
+    watir_definition.should be_visible
+  end
+
+  it "should determine if a web object is not visible" do
+    watir_browser.should_receive(:present?).and_return(false)
+    watir_definition.visible?.should == false
+  end
+
+  it "should determine if a web object exists" do
+    watir_browser.should_receive(:exists?).and_return(true)
+    watir_definition.exists?.should == true
+  end
+
+  it "should determine if a web object does not exist" do
+    watir_browser.should_receive(:exists?).and_return(false)
+    watir_definition.exists?.should == false
+  end
+
+  it "should retrieve the id of a web object" do
+    watir_browser.should_receive(:id).and_return("id")
+    watir_definition.id.should == "id"
+  end
+
+  it "should retrieve the value of a web object" do
+    watir_browser.should_receive(:value).and_return("value")
+    watir_definition.value.should == "value"
+  end
+
+  it "should be able to flash a web_object" do
+    watir_browser.should_receive(:flash).and_return(watir_definition)
+    watir_definition.flash.should be_instance_of Symbiont::WebObjects::WebObject
+  end
+
+  it "should retrieve the value of an attribute" do
+    watir_browser.should_receive(:attribute_value).and_return(true)
+    watir_definition.attribute("readonly").should be_true
+  end
+
+  it "should be able to focus on a web object" do
+    watir_browser.should_receive(:focus).and_return(watir_definition)
+    watir_definition.focus
+  end
+
+  it "should return the text contained by a web object" do
+    watir_browser.should_receive(:text).and_return("testing")
+    watir_definition.text.should == "testing"
+  end
+
+  it "should retrieve the html of a web object" do
+    watir_browser.should_receive(:html).and_return("<p>Testing</p>")
+    watir_definition.html.should == "<p>Testing</p>"
+  end
+
+  it "should simulate a click event on a web object" do
+    watir_browser.should_receive(:click)
+    watir_definition.click
+  end
+
+  it "should simulate a double-click event on a web object" do
+    watir_browser.should_receive(:double_click)
+    watir_definition.double_click
+  end
+
+  it "should retrieve the tag of a web object" do
+    watir_browser.should_receive(:tag_name).and_return("div")
+    watir_definition.tag_name.should == "div"
+  end
+
+  it "should allow a clear event on a web object" do
+    watir_browser.should_receive(:clear)
+    watir_definition.clear
+  end
+
+  it "should retrieve the style of a web object" do
+    watir_browser.should_receive(:style).with('display').and_return("none")
+    watir_definition.style('display').should == 'none'
+  end
+
+  it "should be able to inspect a web object" do
+    watir_browser.should_receive(:inspect).and_return(watir_definition)
+    watir_definition.inspect.should be_instance_of Symbiont::WebObjects::WebObject
+  end
+
+  it "should be able to hover over a web object" do
+    watir_browser.should_receive(:hover).and_return(watir_definition)
+    watir_definition.hover
+  end
+
+  it "should be able to fire an event on a web object" do
+    watir_browser.should_receive(:fire_event).and_return("onclick")
+    watir_definition.fire_event("onclick")
+  end
+
+  it "should send key presses to a web object" do
+    watir_browser.should_receive(:send_keys).with([:control, 'a'])
+    watir_definition.send_keys([:control, 'a'])
+  end
+
+  it "should be able to determine if a web object is equal to another" do
+    watir_browser.should_receive(:==).and_return(true)
+    watir_definition.should == watir_definition
+  end
+
+  it "should find the parent for a web object" do
+    watir_browser.should_receive(:tag_name).twice.and_return(:p)
+    watir_browser.should_receive(:parent).and_return(watir_definition)
+    watir_definition.parent
+  end
+
+  it "should wait until a specific condition occurs" do
+    Object::Watir::Wait.stub(:until).with(5, "Condition occurred.")
+    watir_definition.wait_until(5, "Condition occurred.") { true }
+  end
+
+  it "should wait for a web object to be actionable" do
+    watir_browser.should_receive(:wait_until_present).twice.with(5)
+    watir_definition.when_actionable(5)
+    watir_definition.when_present(5)
+  end
+
+  it "should use the provided element wait time for actionable checks" do
+    Symbiont.element_level_wait = 30
+    watir_browser.should_receive(:wait_until_present).with(30)
+    watir_definition.when_present
+  end
+
+  it "should reference a web object when it is actionable" do
+    watir_browser.should_receive(:wait_until_present).with(5)
+    web_object = watir_definition.when_actionable(5)
+    web_object.should === watir_definition
+  end
+
+  it "should wait for a web object to become non-actionable" do
+    watir_browser.should_receive(:wait_while_present).and_return(false)
+    watir_definition.when_not_present(5)
+  end
+
+  it "should wait for a web object to become visible" do
+    watir_browser.should_receive(:present?).and_return(true)
+    watir_definition.when_visible(5)
+  end
+
+  it "should reference a web object when it is visible" do
+    watir_browser.should_receive(:present?).and_return(true)
+    web_object = watir_definition.when_visible(5)
+    web_object.should === watir_definition
+  end
+
+  it "should wait for a web object to become invisible" do
+    watir_browser.should_receive(:present?).and_return(false)
+    watir_definition.when_not_visible(5)
+  end
+
+  it "should reference a web object when it is not visible" do
+    watir_browser.stub(:present?).and_return(false)
+    web_object = watir_definition.when_not_visible(5)
+    web_object.should === watir_definition
+  end
+
+  it "should scroll elements into view" do
+    watir_browser.should_receive(:wd).and_return(watir_browser)
+    watir_browser.should_receive(:location_once_scrolled_into_view)
+    watir_definition.scroll_into_view
+  end
+
+  it "should return no key for an unrecognized locator" do
+    [:invalid].each do |s|
+      locator = link.provide_locator_for s => 'value'
+      locator.keys.first.should == nil
+    end
+  end
+end

data/spec/symbiont/web_objects/button_spec.rb

@@ -1,30 +1,38 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Button do
-  describe "implementation" do
-    let(:button_object) { double('button_object') }
-    let(:button) { Symbiont::WebObjects::Button }
-    
-    it "should reference standard usable selectors" do
-      [:class, :id, :name, :index, :xpath].each do |s|
-        locator = button.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-    
-    it "should reference specific usable selectors" do
-      [:value, :text].each do |s|
-        locator = button.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-    
-    it "should register with a submit type" do
-      ::Symbiont::WebObjects.get_class_for(:input, :submit).should == ::Symbiont::WebObjects::Button
-    end
-    
-    it "should register with a button type" do
-      ::Symbiont::WebObjects.get_class_for(:input, :button).should == ::Symbiont::WebObjects::Button
-    end
-  end
-end
+require 'spec_helper'
+
+describe Symbiont::WebObjects::Button do
+  describe "implementation" do
+    let(:button_object) { double('button_object') }
+    let(:button) { Symbiont::WebObjects::Button }
+
+    it "should reference standard usable selectors" do
+      [:class, :id, :name, :index, :xpath, :value, :src, :alt, :text].each do |s|
+        locator = button.provide_locator_for s => 'value'
+        locator.keys.first.should == s
+      end
+    end
+
+    it "should reference specific usable selectors" do
+      [:value, :text].each do |s|
+        locator = button.provide_locator_for s => 'value'
+        locator.keys.first.should == s
+      end
+    end
+
+    it "should register with a submit type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :submit).should == ::Symbiont::WebObjects::Button
+    end
+
+    it "should register with a button type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :button).should == ::Symbiont::WebObjects::Button
+    end
+
+    it "should register with an image type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :image).should == ::Symbiont::WebObjects::Button
+    end
+
+    it "should register with an image type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :reset).should == ::Symbiont::WebObjects::Button
+    end
+  end
+end

data/spec/symbiont/web_objects/checkbox_spec.rb

@@ -1,27 +1,27 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::CheckBox do
-  describe "implementation" do
-    let(:checkbox_object) { double('checkbox_object') }
-    let(:checkbox_definition) { Symbiont::WebObjects::CheckBox.new(checkbox_object) }
-    
-    it "should register with a submit type" do
-      ::Symbiont::WebObjects.get_class_for(:input, :checkbox).should == ::Symbiont::WebObjects::CheckBox
-    end
-    
-    it "should be able to check the definition" do
-      checkbox_object.should_receive(:set)
-      checkbox_definition.check
-    end
-    
-    it "should be able to uncheck the definition" do
-      checkbox_object.should_receive(:clear)
-      checkbox_definition.uncheck
-    end
-    
-    it "should be able to determine if the definition is checked" do
-      checkbox_object.should_receive(:set?).and_return(true)
-      checkbox_definition.checked?
-    end
-  end
-end
+require 'spec_helper'
+
+describe Symbiont::WebObjects::CheckBox do
+  describe "implementation" do
+    let(:checkbox_object) { double('checkbox_object') }
+    let(:checkbox_definition) { Symbiont::WebObjects::CheckBox.new(checkbox_object) }
+
+    it "should register with a submit type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :checkbox).should == ::Symbiont::WebObjects::CheckBox
+    end
+
+    it "should be able to check the definition" do
+      checkbox_object.should_receive(:set)
+      checkbox_definition.check
+    end
+
+    it "should be able to uncheck the definition" do
+      checkbox_object.should_receive(:clear)
+      checkbox_definition.uncheck
+    end
+
+    it "should be able to determine if the definition is checked" do
+      checkbox_object.should_receive(:set?).and_return(true)
+      checkbox_definition.checked?
+    end
+  end
+end

data/spec/symbiont/web_objects/div_spec.rb

@@ -1,11 +1,18 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Div do
-  describe "implementation" do
-    let(:div_object) { double('div_object') }
-    
-    it "should register with a div tag" do
-      ::Symbiont::WebObjects.get_class_for(:div).should == ::Symbiont::WebObjects::Div
-    end
-  end
-end
+require 'spec_helper'
+
+describe Symbiont::WebObjects::Div do
+  describe "implementation" do
+    let(:div_object) { Symbiont::WebObjects::Div }
+
+    it "should allow locators to be used" do
+      [:class, :id, :text, :index, :xpath, :title, :name].each do |t|
+        locator = div_object.provide_locator_for t => 'value'
+        locator.keys.first.should == t
+      end
+    end
+
+    it "should register with a div tag" do
+      ::Symbiont::WebObjects.get_class_for(:div).should == ::Symbiont::WebObjects::Div
+    end
+  end
+end

data/spec/symbiont/web_objects/heading_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::Heading do
+  describe "implementation" do
+    let(:heading_object) { Symbiont::WebObjects::Heading }
+
+    it "should allow locators to be used" do
+      [:class, :id, :index, :xpath, :name].each do |t|
+        locator = heading_object.provide_locator_for t => 'value'
+        locator.keys.first.should == t
+      end
+    end
+
+    it "should register with an h1 tag" do
+      ::Symbiont::WebObjects.get_class_for(:h1).should == ::Symbiont::WebObjects::Heading
+    end
+
+    it "should register with an h2 tag" do
+      ::Symbiont::WebObjects.get_class_for(:h2).should == ::Symbiont::WebObjects::Heading
+    end
+  end
+end

data/spec/symbiont/web_objects/hidden_field_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::HiddenField do
+  describe "implementation" do
+    let(:hidden_field_object) { Symbiont::WebObjects::HiddenField }
+
+    it "should reference standard usable selectors" do
+      [:class, :id, :name, :index, :xpath, :value, :text].each do |s|
+        locator = hidden_field_object.provide_locator_for s => 'value'
+        locator.keys.first.should == s
+      end
+    end
+
+    it "should register with a hidden tag" do
+      ::Symbiont::WebObjects.get_class_for(:hidden).should == ::Symbiont::WebObjects::HiddenField
+    end
+  end
+end

data/spec/symbiont/web_objects/label_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::Label do
+  describe "implementation" do
+    let(:label_object) { Symbiont::WebObjects::Label }
+
+    it "should allow locators to be used" do
+      [:class, :id, :text, :index, :xpath].each do |t|
+        locator = label_object.provide_locator_for t => 'value'
+        locator.keys.first.should == t
+      end
+    end
+
+    it "should register with a label tag" do
+      ::Symbiont::WebObjects.get_class_for(:label).should == ::Symbiont::WebObjects::Label
+    end
+  end
+end