symbiont 0.2.1 → 0.3.0

data/spec/symbiont/web_object_spec.rb

@@ -1,194 +0,0 @@
-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,38 +0,0 @@
-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 +0,0 @@
-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,18 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

data/spec/symbiont/web_objects/link_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Link do
-  describe "implementation" do
-    let(:link_object) { double('link_object') }
-    let(:link) { Symbiont::WebObjects::Link }
-
-    it "should reference standard usable selectors" do
-      [:class, :id, :name, :index, :xpath].each do |s|
-        locator = link.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-
-    it "should reference specific usable selectors" do
-      [:href, :text, :title, :css].each do |s|
-        locator = link.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-
-    it "should reference mappable selectors" do
-      [:link, :link_text].each do |s|
-        locator = link.provide_locator_for s => 'value'
-        locator.keys.first.should == :text
-      end
-    end
-
-    it "should register with an anchor tag" do
-      ::Symbiont::WebObjects.get_class_for(:a).should == ::Symbiont::WebObjects::Link
-    end
-  end
-end

data/spec/symbiont/web_objects/list_item_spec.rb

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

data/spec/symbiont/web_objects/option_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Option do
-  describe "implementation" do
-    it "should register with an option tag" do
-      ::Symbiont::WebObjects.get_class_for(:option).should == ::Symbiont::WebObjects::Option
-    end
-  end
-end

data/spec/symbiont/web_objects/ordered_list_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::OrderedList do
-  describe "implementation" do
-    let(:ordered_list_object) { Symbiont::WebObjects::OrderedList }
-
-    it "should allow locators to be used" do
-      [:class, :id, :index, :xpath, :name].each do |t|
-        locator = ordered_list_object.provide_locator_for t => 'value'
-        locator.keys.first.should == t
-      end
-    end
-
-    it "should register with a ordered list (ol) tag" do
-      ::Symbiont::WebObjects.get_class_for(:ol).should == ::Symbiont::WebObjects::OrderedList
-    end
-
-    context "on the watir platform" do
-      let(:ol_element) { double('ol_element') }
-      let(:watir_ordered_list) { Symbiont::WebObjects::OrderedList.new(ol_element) }
-
-      it "should return a list item when indexed" do
-        ol_element.stub(:ols).and_return([ol_element])
-        ol_element.stub(:find_elements).and_return(ol_element)
-        ol_element.stub(:map).and_return([ol_element])
-        ol_element.stub(:parent).and_return(ol_element)
-        ol_element.stub(:element).and_return(ol_element)
-        ol_element.stub(:==).and_return(true)
-        watir_ordered_list[1]
-      end
-
-      it "should know how many list items it contains" do
-        ol_element.stub(:ols).and_return([ol_element])
-        ol_element.stub(:find_elements).and_return(ol_element)
-        ol_element.stub(:map).and_return([ol_element])
-        ol_element.stub(:parent).and_return(ol_element)
-        ol_element.stub(:element).and_return(ol_element)
-        ol_element.stub(:==).and_return(true)
-        watir_ordered_list.items.should == 1
-      end
-
-      it "should iterate over the list items" do
-        watir_ordered_list.should_receive(:items).and_return(5)
-        watir_ordered_list.stub(:[])
-        count = 0
-        watir_ordered_list.each { |item| count += 1 }
-        count.should == 5
-      end
-
-    end
-
-  end
-end

data/spec/symbiont/web_objects/paragraph_spec.rb

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

data/spec/symbiont/web_objects/radio_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Radio do
-  describe "implementation" do
-    let(:radio_object) { double('radio_object') }
-    let(:radio) { Symbiont::WebObjects::Radio.new(radio_object) }
-
-    it "should register with a radio type" do
-      ::Symbiont::WebObjects.get_class_for(:input, :radio).should == ::Symbiont::WebObjects::Radio
-    end
-
-    it "should be able to select a radio" do
-      radio_object.should_receive(:set).and_return(true)
-      radio.select
-    end
-
-    it "should be able to clear a radio" do
-      radio_object.should_receive(:clear).and_return(true)
-      radio.clear
-    end
-
-    it "should be able to see if a radio is selected" do
-      radio_object.should_receive(:set?).and_return(true)
-      radio.selected?
-    end
-  end
-end

data/spec/symbiont/web_objects/select_list_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::SelectList do
-  describe "implementation" do
-    let(:select_list_object) { double('select_list_object') }
-    let(:select_list) { Symbiont::WebObjects::SelectList }
-    let(:select_list_actual) { Symbiont::WebObjects::SelectList.new(select_list_object) }
-    let(:list_opts) { [select_list_object, select_list_object] }
-
-    before(:each) do
-      select_list_object.stub(:find_elements).and_return(select_list_object)
-      select_list_object.stub(:wd).and_return(select_list_object)
-      select_list_object.stub(:include?)
-    end
-
-    it "should reference standard usable selectors" do
-      [:class, :id, :name, :index, :xpath].each do |s|
-        locator = select_list.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-
-    it "should register with a select list tag" do
-      ::Symbiont::WebObjects.get_class_for(:select).should == ::Symbiont::WebObjects::SelectList
-    end
-
-    it "should return an option when indexed" do
-      select_list_object.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(list_opts)
-      select_list_actual[0].should be_instance_of Symbiont::WebObjects::Option
-    end
-
-    it "should return an array of options" do
-      select_list_object.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(list_opts)
-      select_list_actual.options.size.should == 2
-    end
-
-    it "should return an array of selected options" do
-      select_list_object.stub(:selected_options).and_return(list_opts)
-      select_list_object.stub(:text).and_return(select_list_object)
-      select_list_actual.selected_options.should == list_opts
-    end
-
-    it "should determine if an option is selected" do
-      select_list_object.stub(:selected?).with('testing').and_return(true)
-      select_list_actual.selected?('testing')
-    end
-
-    it "should determine if an option is available" do
-      select_list_object.stub(:include?).with('testing').and_return(true)
-      select_list_actual.include?('testing')
-    end
-
-    it "should get the values for any selected options" do
-      select_list_object.stub(:selected_options).and_return(list_opts)
-      select_list_object.stub(:value).and_return(select_list_object)
-      select_list_actual.selected_values.should == list_opts
-    end
-
-    it "should be able to select an item by value" do
-      select_list_object.should_receive(:select_value).and_return(true)
-      select_list_actual.select_value('testing')
-    end
-
-    it "should be able to select an item by option" do
-      select_list_object.should_receive(:select).and_return(true)
-      select_list_actual.select('testing')
-    end
-  end
-end

data/spec/symbiont/web_objects/span_spec.rb

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

data/spec/symbiont/web_objects/table_cell_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::TableCell do
-  describe "implementation" do
-    it "should register with a table definition tag" do
-      ::Symbiont::WebObjects.get_class_for(:td).should == ::Symbiont::WebObjects::TableCell
-    end
-
-    it "should register with a table header tag" do
-      ::Symbiont::WebObjects.get_class_for(:th).should == ::Symbiont::WebObjects::TableCell
-    end
-
-    it "should always be enabled" do
-      table_cell_object = double('table_cell_object')
-      table_cell = Symbiont::WebObjects::TableCell.new(table_cell_object)
-      table_cell.enabled?.should be_true
-    end
-  end
-end

data/spec/symbiont/web_objects/table_row_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::TableRow do
-  describe "implementation" do
-    let(:table_cell) { double('table_cell') }
-    let(:table_row_object) { double('table_row_object') }
-
-    context "on the watir platform" do
-      it "should return a table cell when indexed" do
-        table_row = Symbiont::WebObjects::TableRow.new(table_row_object)
-        table_row_object.should_receive(:[]).with(1).and_return(table_cell)
-
-        table_row_object.should_receive(:size).and_return(3)
-        table_row_object.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_object)
-        table_row_object.should_receive(:wd).and_return(table_row_object)
-
-        table_row[1].should be_instance_of Symbiont::WebObjects::TableCell
-      end
-
-      it "should return the number of columns" do
-        table_row = Symbiont::WebObjects::TableRow.new(table_row_object)
-        table_row_object.stub(:wd).and_return(table_row_object)
-        table_row_object.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_object)
-        table_row_object.should_receive(:size).and_return(3)
-        table_row.columns.should == 3
-      end
-
-      it "should iterate over the table columns" do
-        table_row = Symbiont::WebObjects::TableRow.new(table_row_object)
-        table_row.should_receive(:columns).and_return(2)
-        table_row.stub(:[]).and_return(table_row_object)
-        count = 0
-        table_row.each { |e| count += 1 }
-        count.should == 2
-      end
-
-      #it "should return a row using text from the first row" do
-      #table_row = Symbiont::WebObjects::TableRow.new(table_row_object)
-      #table_row_object.should_receive(:[]).with("column_text").and_return(table_row_object)
-      #table_row_object.should_receive(:[]).with(0).and_return(table_row_object)
-      #table_row_object.should_receive(:tag_name)
-      #table_row_object.should_receive(:parent).and_return(table_row_object)
-      #table_row_object.should_receive(:cells).and_return(table_row_object)
-      #table_row_object.should_receive(:find_index).and_return("column_text")
-
-      #table_row_object.should_receive(:size).and_return(1)
-      #table_row_object.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_object)
-      #table_row_object.should_receive(:wd).and_return(table_row_object)
-
-      #table_row[1]["column_text"].should be_instance_of Symbiont::WebObjects::TableCell
-      #end
-
-      it "should register with a table row tag" do
-        ::Symbiont::WebObjects.get_class_for(:tr).should == ::Symbiont::WebObjects::TableRow
-      end
-    end
-  end
-end