symbiont 0.1.8 → 0.1.9

data/lib/symbiont/web_objects/radio.rb

@@ -3,30 +3,24 @@ module Symbiont
     
     class Radio < WebObject
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
 
-      def self.usable_selectors_for_watir
+      def self.usable_selectors
         super + [:value]
       end
 
-      def self.usable_selectors_for_selenium
-        super + [:value]
+      def select
+        web_object.set
+      end
+
+      def clear
+        web_object.clear
       end
 
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :watir_webdriver
-          require 'symbiont/platform_watir/web_objects/radio'
-          self.class.send :include, Symbiont::Platforms::WatirWebDriver::Radio
-        elsif platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/radio'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::Radio
-        else
-          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
-        end
+      def selected?
+        web_object.set?
       end
 
     end # class: Radio

data/lib/symbiont/web_objects/select_list.rb

@@ -2,33 +2,78 @@ module Symbiont
   module WebObjects
     
     class SelectList < WebObject
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
 
-      def self.usable_selectors_for_watir
+      def self.usable_selectors
         super + [:value, :text]
       end
 
+      # This method is used to return an Option object based on the index provided.
+      # @return [Symbiont::WebObjects::Option]
+      def [](idx)
+        ::Symbiont::WebObjects::Option.new(options[idx])
+      end
+
+      # Selects an option from the select list.
+      def select(value)
+        web_object.select(value)
+      end
+
+      # Selects the option whose value attribute matches the provided string.
+      def select_value(value)
+        web_object.select_value(value)
+      end
+
+      # This method returns an array of Option objects that are contained within
+      # a select list object.
+      # @return [array of Symbiont::WebObjects::Option]
+      def options
+        web_objects = []
+        options = web_object.wd.find_elements(:xpath, option_xpath)
+        options.each do |opt|
+          web_objects << ::Symbiont::WebObjects::Option.new(opt)
+        end
+        web_objects
+      end
+
+      # This method returns an array of strings that contain the text of the
+      # currently selected options in a select list.
+      # @return [Array<String>]
+      def selected_options
+        web_object.selected_options.map { |e| e.text }.compact
+      end
+
+      # This method returns an array of strings that contain the values of the
+      # currently selected options in a select list.
+      # @return [Array<String>]
+      def selected_values
+        web_object.selected_options.map { |e| e.value }.compact
+      end
+
+      # This method returns true if any of the text or the label of any option
+      # that is selected matches the provided value.
+      # @param [String, Regexp] value A value to check for
+      # @return [Boolean]
+      def selected?(value)
+        web_object.selected? value
+      end
+
+      # This method checks to see if the select list has one or more options
+      # where the text or the label matches the provided value.
+      # @param [String, Regexp] value A value to check for.
+      # @return [Boolean]
+      def include?(value)
+        web_object.include? value
+      end
+
       protected
       
       def option_xpath
         ".//child::option"
       end
 
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :watir_webdriver
-          require 'symbiont/platform_watir/web_objects/select_list'
-          self.class.send :include, Symbiont::Platforms::WatirWebDriver::SelectList
-        elsif platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/select_list'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::SelectList
-        else
-          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
-        end
-      end
     end # class: SelectList
     
     ::Symbiont::WebObjects.class_for_tag[:select] = ::Symbiont::WebObjects::SelectList

data/lib/symbiont/web_objects/span.rb

@@ -3,11 +3,7 @@ module Symbiont
     
     class Span < WebObject
 
-      def self.usable_selectors_for_watir
-        super + [:text, :title]
-      end
-
-      def self.usable_selectors_for_selenium
+      def self.usable_selectors
         super + [:text, :title]
       end
 

data/lib/symbiont/web_objects/table.rb

@@ -4,9 +4,18 @@ module Symbiont
     class Table < WebObject
       include Enumerable
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
+      end
+
+      # This method is used to return a TableRow object based on the index provided. When
+      # the index provided is a string, the text will be matched with the text from the first
+      # column.
+      # @return [Symbiont::WebObjects::TableRow]
+      def [](index)
+        index = find_by_title(index) if index.kind_of?(String)
+        return nil unless index
+        ::Symbiont::WebObjects::TableRow.new(web_object[index])
       end
 
       # This method is an iterator that returns a TableRow object each time through
@@ -18,6 +27,11 @@ module Symbiont
         end
       end
 
+      # This method will return the number of rows in a table.
+      def rows
+        web_object.wd.find_elements(:xpath, row_xpath).size
+      end
+
       # Returns a reference to the first row web object of a table.
       # @return [Symbiont::WebObjects::TableRow]
       def first_row
@@ -36,16 +50,12 @@ module Symbiont
         ".//child::tr"
       end
 
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :watir_webdriver
-          require 'symbiont/platform_watir/web_objects/table'
-          self.class.send :include, Symbiont::Platforms::WatirWebDriver::Table
-        elsif platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/table'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::Table
-        else
-          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
+      private
+
+      def find_by_title(row_text)
+        #web_object.rows.find_index {|row| row[0].text == row_text}
+        web_object.rows.find_index do |row|
+          row.cells.any? { |col| col.text.include? row_text }
         end
       end
 

data/lib/symbiont/web_objects/table_cell.rb

@@ -3,7 +3,7 @@ module Symbiont
     
     class TableCell < WebObject
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
       end
 
@@ -11,11 +11,7 @@ module Symbiont
         true
       end
 
-      def self.usable_selectors_for_watir
-        super + [:text]
-      end
-
-      def self.usable_selectors_for_selenium
+      def self.usable_selectors
         super + [:text]
       end
 

data/lib/symbiont/web_objects/table_row.rb

@@ -4,9 +4,18 @@ module Symbiont
     class TableRow < WebObject
       include Enumerable
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
+      end
+
+      # This method is used to return a TableCell object based on the index provided. When
+      # the index provided is a string, the text will be matched with the text from the
+      # columns in the first row.
+      # @return [Symbiont::WebObjects::TableCell]
+      def [](index)
+        index = find_by_title(index) if index.kind_of?(String)
+        return nil unless index && columns >= index + 1
+        ::Symbiont::WebObjects::TableCell.new(web_object[index])
       end
 
       # This method is an iterator that returns a TableCell object each time through
@@ -18,24 +27,26 @@ module Symbiont
         end
       end
 
+      # This method returns the number of columns in a table object.
+      def columns
+        web_object.wd.find_elements(:xpath, cell_xpath).size
+      end
+
       protected
       
       def cell_xpath
         ".//child::td|th"
       end
 
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :watir_webdriver
-          require 'symbiont/platform_watir/web_objects/table_row'
-          self.class.send :include, Symbiont::Platforms::WatirWebDriver::TableRow
-        elsif platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/table_row'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::TableRow
-        else
-          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
-        end
+      private
+
+      def find_by_title(column_text)
+        table = web_object.parent
+        table = table.parent if table.tag_name == 'tbody'
+        first_row = table[0]
+        first_row.cells.find_index {|column| column.text.include? column_text}
       end
+
     end # class: TableRow
     
     ::Symbiont::WebObjects.class_for_tag[:tr] = ::Symbiont::WebObjects::TableRow

data/lib/symbiont/web_objects/text_field.rb

@@ -2,39 +2,30 @@ module Symbiont
   module WebObjects
 
     class TextField < WebObject
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
 
-      def append(text)
-        web_object.send_keys text
+      def value
+        web_object.value
       end
 
-      def self.usable_selectors_for_watir
-        super + [:title, :value, :text, :label]
+      def value=(value)
+        web_object.set value
       end
 
-      def self.usable_selectors_for_selenium
-        super + [:title, :value, :text, :label]
+      def append(text)
+        web_object.send_keys text
       end
 
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :watir_webdriver
-          require 'symbiont/platform_watir/web_objects/text_field'
-          self.class.send :include, Symbiont::Platforms::WatirWebDriver::TextField
-        elsif platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/text_field'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::TextField
-        else
-          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
-        end
+      def self.usable_selectors
+        super + [:title, :value, :text, :label]
       end
 
     end # class: TextField
     
     ::Symbiont::WebObjects.class_for_type[:text] = ::Symbiont::WebObjects::TextField
     ::Symbiont::WebObjects.class_for_type[:password] = ::Symbiont::WebObjects::TextField
+
   end # module: WebObjects
 end # module: Symbiont

data/lib/symbiont/web_objects.rb

@@ -16,7 +16,7 @@ module Symbiont
       end
     end
     
-  end # module: WebObjects
-end # module: Symbiont
+  end
+end
 
 require 'symbiont/web_objects/_common'

data/lib/symbiont.rb

@@ -14,9 +14,11 @@ module Symbiont
   include Evaluators
   include Locators
   include DataSetter
-  
+
+  # Used to make a platform object accessible. Will hold object
+  # references like these:
+  # <Symbiont::Platforms::WatirWebDriver::PlatformObject:0x2cbe8a0>
   attr_reader :platform
-  attr_reader :browser
 
   def self.version
     "Symbiont v#{Symbiont::VERSION}"
@@ -39,12 +41,20 @@ module Symbiont
     @page_wait ||= 15
   end
 
+  def self.page_level_wait=(value)
+    @page_wait = value
+  end
+
   # Returns the default wait value for elements on a page. This value is
   # the default value beyond which a timeout is assumed.
   def self.element_level_wait
     @element_wait ||= 5
   end
 
+  def self.element_level_wait=(value)
+    @element_wait = value
+  end
+
   # The initialize method will be invoked when a page definition includes
   # Symbiont. Some key things are happening here that are critical to
   # Symbiont working correctly:
@@ -69,7 +79,7 @@ module Symbiont
   #
   # @param [Object] browser a browser instance with a tool driver
   def establish_platform_object_for(browser)
-    @platform = get_platform_for(browser, Symbiont::Platforms.list)
+    @platform = get_platform_for(browser)
   end
 
 end

data/spec/spec_helper.rb

@@ -28,6 +28,7 @@ class DefinitionTest
   radio :include_tax, id: "includeTax"
   table :accounts, id: "accounts"
   cell :totalValue, id: "totalValue"
+  paragraph :intro, id: "intro"
   div :section, id: "section"
   span :inline, id: "inline"
   

data/spec/symbiont/enclosers_spec.rb

@@ -8,6 +8,9 @@ describe Symbiont::Enclosers do
     it "should allow frames to act as a context" do
       watir_browser.should_receive(:frame).with(id: "frame").and_return(watir_browser)
       watir_browser.should_receive(:text_field).and_return(watir_browser)
+      watir_browser.should_receive(:wd).and_return(watir_browser)
+      watir_browser.should_receive(:switch_to).and_return(watir_browser)
+      watir_browser.should_receive(:default_content).and_return(watir_browser)
       web_object = watir_definition.framedLoginName_text_field
       web_object.should_not be_nil
       web_object.should be_instance_of Symbiont::WebObjects::TextField

data/spec/symbiont/evaluators_spec.rb

@@ -65,6 +65,11 @@ describe Symbiont::Enclosers do
         watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(1)
         expect { watir_definition.wait_for_pending_requests(1) }.to raise_error
       end
+
+      it "should be able to go back to a previous page" do
+        watir_browser.should_receive(:back)
+        watir_definition.back
+      end
     end
   end
 end

data/spec/symbiont/generators/button_generators_spec.rb

@@ -52,7 +52,7 @@ describe Symbiont::Generators do
       
       it "should determine if a button is visible" do
         watir_browser.should_receive(:button).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.submit_?.should be_true
         watir_definition.submit_visible?.should be_true
       end

data/spec/symbiont/generators/cell_generators_spec.rb

@@ -37,7 +37,7 @@ describe Symbiont::Generators do
       
       it "should determine if a table cell is visible" do
         watir_browser.should_receive(:td).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.totalValue_visible?.should be_true
         watir_definition.totalValue_?.should be_true
       end

data/spec/symbiont/generators/checkbox_generators_spec.rb

@@ -41,7 +41,7 @@ describe Symbiont::Generators do
       
       it "should determine if a checkbox is visible" do
         watir_browser.should_receive(:checkbox).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.apply_tax_visible?.should be_true
         watir_definition.apply_tax_?.should be_true
       end

data/spec/symbiont/generators/div_generators_spec.rb

@@ -37,12 +37,12 @@ describe Symbiont::Generators do
       
       it "should determine if a div is visible" do
         watir_browser.should_receive(:div).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.section_visible?.should be_true
         watir_definition.section_?.should be_true
       end
       
-      it "should return the text of a span" do
+      it "should return the text of a div" do
         watir_browser.should_receive(:div).and_return(watir_browser)
         watir_browser.should_receive(:text).and_return("testing")
         watir_definition.section.should == "testing"

data/spec/symbiont/generators/link_generators_spec.rb

@@ -49,7 +49,7 @@ describe Symbiont::Generators do
       
       it "should determine if a link is visible" do
         watir_browser.should_receive(:link).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.reset_password_visible?.should be_true
         watir_definition.reset_password_?.should be_true
       end

data/spec/symbiont/generators/paragraph_generators_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Symbiont::Generators do
+  let(:watir_browser) { mock_browser_for_watir }
+  let(:watir_definition) { DefinitionTest.new(watir_browser) }
+
+  describe "paragraph web objects" do
+    context "when declared in a definition" do
+      it "should generate methods for referencing the paragraph" do
+        watir_definition.should respond_to(:intro_paragraph)
+        watir_definition.should respond_to(:intro_object)
+      end
+
+      it "should generate methods for interacting with the paragraph" do
+        watir_definition.should respond_to(:intro_exists?)
+        watir_definition.should respond_to(:intro_visible?)
+        watir_definition.should respond_to(:intro?)
+        watir_definition.should respond_to(:intro_?)
+        watir_definition.should respond_to(:intro)
+      end
+    end
+
+    context "when used by the watir platform" do
+      it "should locate the paragraph" do
+        watir_browser.should_receive(:p).and_return(watir_browser)
+        web_object = watir_definition.intro_paragraph
+        web_object.should_not be_nil
+        web_object.should be_instance_of Symbiont::WebObjects::Paragraph
+      end
+
+      it "should determine if a paragraph exists" do
+        watir_browser.should_receive(:p).twice.and_return(watir_browser)
+        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
+        watir_definition.intro_exists?.should be_true
+        watir_definition.intro?.should be_true
+      end
+
+      it "should determine if a paragraph is visible" do
+        watir_browser.should_receive(:p).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
+        watir_definition.intro_visible?.should be_true
+        watir_definition.intro_?.should be_true
+      end
+
+      it "should return the text of a paragraph" do
+        watir_browser.should_receive(:p).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("testing")
+        watir_definition.intro.should == "testing"
+      end
+    end
+  end
+end

data/spec/symbiont/generators/radio_generators_spec.rb

@@ -8,7 +8,6 @@ describe Symbiont::Generators do
     context "when declared in a definition" do
       it "should generate methods for referencing the radio" do
         watir_definition.should respond_to(:include_tax_radio)
-        watir_definition.should respond_to(:include_tax_radio_button)
         watir_definition.should respond_to(:include_tax_object)
       end
       
@@ -42,7 +41,7 @@ describe Symbiont::Generators do
       
       it "should determine if a radio is visible" do
         watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.include_tax_visible?.should be_true
         watir_definition.include_tax_?.should be_true
       end

data/spec/symbiont/generators/select_list_generators_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Symbiont::Generators do
   let(:watir_browser) { mock_browser_for_watir }
   let(:watir_definition) { DefinitionTest.new(watir_browser) }
-  
+
   describe "select list web objects" do
     context "when declared in a definition" do
       it "should generate methods for referencing the select list" do
@@ -51,7 +51,7 @@ describe Symbiont::Generators do
         watir_browser.should_receive(:select).with("testing")
         watir_definition.concepts = "testing"
       end
-      
+
       it "should determine if a select list exists" do
         watir_browser.should_receive(:select_list).twice.and_return(watir_browser)
         watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
@@ -61,7 +61,7 @@ describe Symbiont::Generators do
       
       it "should determine if a select list is visible" do
         watir_browser.should_receive(:select_list).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.concepts_visible?.should be_true
         watir_definition.concepts_?.should be_true
       end

data/spec/symbiont/generators/span_generators_spec.rb

@@ -37,7 +37,7 @@ describe Symbiont::Generators do
       
       it "should determine if a span is visible" do
         watir_browser.should_receive(:span).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.inline_visible?.should be_true
         watir_definition.inline_?.should be_true
       end

data/spec/symbiont/generators/table_generators_spec.rb

@@ -16,6 +16,7 @@ describe Symbiont::Generators do
         watir_definition.should respond_to(:accounts?)
         watir_definition.should respond_to(:accounts_visible?)
         watir_definition.should respond_to(:accounts_?)
+        watir_definition.should respond_to(:accounts)
       end
     end
     
@@ -36,10 +37,16 @@ describe Symbiont::Generators do
       
       it "should determine if a table is visible" do
         watir_browser.should_receive(:table).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.accounts_visible?.should be_true
         watir_definition.accounts_?.should be_true
       end
+
+      it "should return the text of a table" do
+        watir_browser.should_receive(:table).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("testing")
+        watir_definition.accounts.should == "testing"
+      end
     end
   end
 end

data/spec/symbiont/generators/text_field_generators_spec.rb

@@ -52,7 +52,7 @@ describe Symbiont::Generators do
   
       it "should determine if a text field is visible" do
         watir_browser.should_receive(:text_field).twice.and_return(watir_browser)
-        watir_browser.should_receive(:visible?).twice.and_return(watir_browser)
+        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
         watir_definition.login_name_visible?.should be_true
         watir_definition.login_name_?.should be_true
       end

data/spec/symbiont/symbiont_spec.rb

@@ -14,4 +14,14 @@ describe Symbiont do
     Symbiont.instance_variable_set("@page_wait", nil)
     Symbiont.page_level_wait.should == 15
   end
+
+  it "should provide an element level wait default" do
+    Symbiont.instance_variable_set("@element_wait", 5)
+    Symbiont.element_level_wait.should == 5
+  end
+
+  it "should set the element level wait default to 5" do
+    Symbiont.instance_variable_set("@element_wait", nil)
+    Symbiont.element_level_wait.should == 5
+  end
 end