symbiont 0.1.0 → 0.1.1

data/lib/symbiont.rb

@@ -3,9 +3,12 @@ require 'symbiont/logger'
 require 'symbiont/platforms'
 require 'symbiont/generators'
 require 'symbiont/enclosers'
+require 'symbiont/evaluators'
 
 module Symbiont
   include Platforms
+  include Enclosers
+  include Evaluators
   
   # Used to make a platform object accessible. Will hold object
   # references like these:

data/lib/symbiont/enclosers.rb

@@ -22,5 +22,22 @@ module Symbiont
       block.call(encloser)
     end
     
+    # Provides a context for an action that must succeed within a given time period.
+    # The logic here is simply that the result of the action will be true (meaning
+    # the action was carried out) or false, which means the action did not succeed
+    # in the time allotted.
+    #
+    # @param [Integer] timeout the amount of time in seconds to wait
+    # @param [String] message the text to return if the action did not occur in time
+    # @param [Proc] block the code that calls the desired action
+    #
+    # @example
+    #   @page.wait_for(5, 'page with expected title not found') do
+    #     @page.title.should == "Test App"
+    #   end
+    def wait_for(timeout=10, message=nil, &block)
+      @platform.wait_for(timeout, message, &block)
+    end
+    
   end # module: Enclosers
 end # module: Symbiont

data/lib/symbiont/evaluators.rb

@@ -0,0 +1,17 @@
+module Symbiont
+  module Evaluators
+    
+    # Visits a page via a specified URL. The URL can be specified as a domain
+    # address or as a file-based link.
+    # @param [String] url the full URL to navigate to
+    def visit(url)
+      @platform.visit(url)
+    end
+    
+    # Returns the text of the current page.
+    def text
+      @platform.text
+    end
+    
+  end # module: Evaluators
+end # module: Symbiont

data/lib/symbiont/platform_watir/platform_object.rb

@@ -7,13 +7,33 @@ module Symbiont
         def initialize(browser)
           @browser = browser
         end
-
+        
+        ## Browser-Level Actions ##
+        
         # Platform method to make a call to a specified URL.
-        # See Symbiont::Generators#url_is
+        # See Symbiont#visit
         def visit(url)
           @browser.goto(url)
         end
         
+        ## Page-Level Actions ##
+        
+        # Platform method to retrieve text from the current page.
+        # See Symbiont#text
+        def text
+          @browser.text
+        end
+        
+        ## Encloser Methods ##
+        
+        # Platform method to wait for an action to complete in a given time.
+        # @see Symbiont::Enclosers#wait_for
+        def wait_for(timeout, message=nil, &block)
+          @browser.wait_until(timeout, message, &block)
+        end
+        
+        ## Generator Methods ##
+        
         # Platform method to return a link object.
         # Link objects are of type: Symbiont::WebObjects::Link
         # @see Symbiont::Generators#link

data/lib/symbiont/version.rb

@@ -1,3 +1,3 @@
 module Symbiont
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/symbiont/web_objects/_common.rb

@@ -31,10 +31,45 @@ module Symbiont
         @web_object.text
       end
       
-      def when_actionable(timeout)
+      def click
+        @web_object.click
+      end
+      
+      def attribute(name)
+        @web_object.attribute_value(name)
+      end
+      
+      def style(property)
+        @web_object.style(property)
+      end
+      
+      def when_actionable(timeout=5)
         @web_object.wait_until_present(timeout)
         self
       end
+      
+      alias :when_present :when_actionable
+      
+      def when_visible(timeout=5)
+        Object::Watir::Wait.until(timeout, "object not visible within #{timeout} seconds.") do
+          visible?
+        end
+        self
+      end
+      
+      def when_not_visible(timeout=5)
+        Object::Watir::Wait.while(timeout, "object still visible after #{timeout} seconds.") do
+          visible?
+        end
+        self
+      end
+      
+      alias :must_be_visible :when_visible
+      alias :must_not_be_visible :when_not_visible
+      
+      def wait_until(timeout, message=nil, &block)
+        Object::Watir::Wait.until(timeout, message, &block)
+      end
     end # class: WebObject
 
   end # module: WebObjects

data/lib/symbiont/web_objects/table.rb

@@ -9,6 +9,15 @@ module Symbiont
         Object::Symbiont::WebObjects::TableRow.new(@web_object[index])
       end
       
+      # This method is an iterator that returns a TableRow object each time through
+      # the loop.
+      # @return [Symbiont::WebObjects::TableRow]
+      def each
+        for index in 1..self.rows do
+          yield self[index - 1]
+        end
+      end
+      
       # This method will return the number of rows in a table.
       def rows
         @web_object.wd.find_elements(:xpath, row_xpath).size

data/lib/symbiont/web_objects/table_row.rb

@@ -9,6 +9,15 @@ module Symbiont
         Object::Symbiont::WebObjects::TableCell.new(@web_object[index])
       end
       
+      # This method is an iterator that returns a TableCell object each time through
+      # the loop.
+      # @return [Symbiont::WebObjects::TableCell]
+      def each
+        for index in 1..self.columns do
+          yield self[index - 1]
+        end
+      end
+      
       # This method returns the number of columns in a table object.
       def columns
         @web_object.wd.find_elements(:xpath, cell_xpath).size

data/spec/symbiont/enclosers_spec.rb

@@ -12,5 +12,10 @@ describe Symbiont::Enclosers do
       web_object.should_not be_nil
       web_object.should be_instance_of Symbiont::WebObjects::TextField
     end
+    
+    it "should wait for a condition to be true" do
+      watir_browser.should_receive(:wait_until).with(5, "not quick enough")
+      watir_definition.wait_for(5, "not quick enough")
+    end
   end
 end

data/spec/symbiont/evaluators_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Symbiont::Enclosers do
+  let(:watir_browser) { mock_browser_for_watir }
+  let(:watir_definition) { DefinitionTest.new(watir_browser) }
+  
+  describe "browser-level actions" do
+    context "a definition using watir-webdriver" do
+      it "should visit a page" do
+        watir_browser.should_receive(:goto).with("http://localhost:4567")
+        watir_definition.visit("http://localhost:4567")
+      end
+    end
+  end
+  
+  describe "page-level actions" do
+    context "a definition using watir-webdriver" do
+      it "should return all the text on a page" do
+        watir_browser.should_receive(:text).and_return("page text")
+        watir_definition.text.should == "page text"
+      end
+    end
+  end
+end

data/spec/symbiont/web_object_spec.rb

@@ -4,6 +4,16 @@ describe "Web Objects" do
   let(:watir_browser) { mock_browser_for_watir }
   let(:watir_definition) { ::Symbiont::WebObjects::WebObject.new(watir_browser) }
   
+  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 determine if a web object is enabled" do
     watir_browser.should_receive(:enabled?).and_return(true)
     watir_definition.enabled?.should == true
@@ -19,19 +29,67 @@ describe "Web Objects" do
     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(:visible?).and_return(true)
     watir_definition.visible?.should == true
   end
   
+  it "should determine if a web object is not visible" do
+    watir_browser.should_receive(:visible?).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 wait for web object to be actionable" do
-    watir_browser.stub(:wait_until_present).with(5)
+  it "should simulate a click event on a web object" do
+    watir_browser.should_receive(:click)
+    watir_definition.click
+  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 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 visible" do
+    watir_browser.should_receive(:visible?).and_return(true)
+    watir_definition.when_visible(5)
+  end
+  
+  it "should reference a web object when it is visible" do
+    watir_browser.should_receive(:visible?).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(:visible?).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(:visible?).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
 end

data/spec/symbiont/web_objects/table_row_spec.rb

@@ -19,6 +19,15 @@ describe Symbiont::WebObjects::TableRow do
         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
     end
   end
 end

data/spec/symbiont/web_objects/table_spec.rb

@@ -28,6 +28,14 @@ describe Symbiont::WebObjects::Table do
         table_object.should_receive(:size).and_return(2)
         watir_table.rows.should == 2
       end
+      
+      it "should iterate over the table rows" do
+        watir_table.should_receive(:rows).and_return(2)
+        table_object.stub(:[]).and_return(table_object)
+        count = 0
+        watir_table.each { |e| count += 1 }
+        count.should == 2
+      end
     end
   end
 end

data/specs/button.feature

@@ -39,3 +39,5 @@ Feature: Ability to Support Button Web Objects
       | class   |
       | xpath   |
       | index   |
+      | value   |
+      | text    |

data/specs/definitions/pages.rb

@@ -21,12 +21,16 @@ class SimpleObjectPage
   link :avengersClass, class: "avengersClass"
   link :avengersXPath, xpath: "id('avengersID')"
   link :avengersIndex, {id: "avengersID", index: 0}
+  link :avengersText, text: "Avengers Assemble"
+  link :avengersHref, href: "success_1"
   
   button :clickmeID, id: "clickmeID"
   button :clickmeName, name: "clickmeName"
   button :clickmeClass, class: "clickmeClass"
   button :clickmeXPath, xpath: "//input[@id='clickmeID']"
   button :clickmeIndex, {id: "clickmeID", index: 0}
+  button :clickmeValue, value: "Click Me"
+  button :clickmeText, text: "Click Me"
   
   button :cantClickMeID, id: "cantclickmeID"
   
@@ -38,6 +42,7 @@ class SimpleObjectPage
   text_field :bookTitleXPath, xpath: "//input[@id='bookTitleID']"
   text_field :bookTitleIndex, {id: "bookTitleID", index: 0}
   
+  text_field :bookRefID, id: "bookRefID"
   text_field :bookPubID, id: "bookPubID"
   text_field :fake_text_field, id: "fake_text_field"
   
@@ -91,6 +96,18 @@ class SimpleObjectPage
   span :spanTextClass, class: "spanTextClass"
 end
 
+class SimpleEventsPage
+  include Symbiont
+  
+  url_is "http://localhost:4567/test_events"
+  
+  button :conditional, id: "conditional"
+  button :hideButton, value: "Hide Button"
+  button :revealButton, value: "Reveal Button"
+  button :createButton, value: "Create Button"
+  button :removeButton, value: "Remove Button"
+end
+
 class LoggingIn
   include Symbiont
   begin_at "http://localhost:4567/test_database"

data/specs/evaluators.feature

@@ -0,0 +1,5 @@
+Feature: Ability to handle browser and page actions.
+
+  Scenario: Getting web page text
+    When on the object test page
+    Then the page should contain the text "Multiphasic Temporal Convergence"

data/specs/events.feature

@@ -0,0 +1,19 @@
+Feature: Ability to Handle Events or Time-Based Situations
+  
+  Scenario: Waiting for a general condition
+    When performing a successful action on the object test page
+    Then the test should wait for a success page    
+  
+  Scenario: Waiting for an object to be invisible
+    When on the events test page
+    Then the conditional button can be clicked
+    When the conditional button is hidden
+    Then the test will wait until the conditional button is invisible
+    And after that time the conditional button should not be visible
+
+  Scenario: Waiting for an object to be visible
+    When the conditional button on the events test page is invisible
+    And the conditional button is revealed
+    Then the test will wait until the conditional button is visible before clicking it
+    
+    

data/specs/link.feature

@@ -30,3 +30,5 @@ Feature: Ability to Support Link Web Objects
       | class   |
       | xpath   |
       | index   |
+      | text    |
+      | href    |

data/specs/support/test_steps/action_steps_buttons.rb

@@ -10,6 +10,8 @@ When (/^the click me button on the object test page is clicked by "([^"]*)"$/) d
   @page.clickmeClass if locator == "class"
   @page.clickmeXPath if locator == "xpath"
   @page.clickmeIndex if locator == "index"
+  @page.clickmeValue if locator == "value"
+  @page.clickmeText if locator == "text"
 end
 
 Then (/^the click me button should exist$/) do

data/specs/support/test_steps/action_steps_evaluators.rb

@@ -0,0 +1,3 @@
+Then (/^the page should contain the text "([^"]*)"$/) do |text|
+  @page.text.include? text
+end

data/specs/support/test_steps/action_steps_events.rb

@@ -0,0 +1,40 @@
+When (/^performing a successful action on the object test page$/) do
+  step %{on the object test page}
+  @page.clickmeID
+end
+
+When (/^the conditional button is hidden$/) do
+  @page.hideButton
+end
+
+When (/^the conditional button is revealed$/) do
+  @page.revealButton
+end
+
+When (/^the conditional button on the events test page is invisible$/) do
+  step %{on the events test page}
+  step %{the conditional button is hidden}
+end
+
+Then (/^the test should wait for a success page$/) do
+  @page.wait_for(10, "success page did not come up in time") do
+    @page.text.include? 'Success'
+  end
+end
+
+Then (/^the conditional button can be clicked$/) do
+  @page.conditional
+end
+
+Then (/^the test will wait until the conditional button is invisible$/) do
+  @page.conditional_button.when_not_visible
+end
+
+Then (/^after that time the conditional button should not be visible$/) do
+  @page.conditional_visible?.should == false
+end
+
+Then (/^the test will wait until the conditional button is visible before clicking it$/) do
+  @page.conditional_button.when_visible
+  @page.conditional
+end