symbiont 0.1.9 → 0.2.0

data/spec/symbiont/web_objects/link_spec.rb

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

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

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

@@ -2,9 +2,16 @@ require 'spec_helper'
 
 describe Symbiont::WebObjects::Paragraph do
   describe "implementation" do
-    let(:p_object) { double('p_object') }
+    let(:p_object) { Symbiont::WebObjects::Paragraph }
 
-    it "should register with a paragraph tag" do
+    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

data/spec/symbiont/web_objects/radio_spec.rb

@@ -1,27 +1,27 @@
-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
+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 +1,69 @@
-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
+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,11 +1,18 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Span do
-  describe "implementation" do
-    let(:span_object) { double('span_object') }
-    
-    it "should register with a span tag" do
-      ::Symbiont::WebObjects.get_class_for(:span).should == ::Symbiont::WebObjects::Span
-    end
-  end
-end
+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 +1,19 @@
-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
+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 +1,58 @@
-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
+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