commonwatir 1.6.2

data/History.txt

@@ -0,0 +1,5 @@
+=== 0.0.1 / 2008-08-28
+
+* Created
+
+

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/watir.rb
+lib/watir-common.rb
+lib/watir/assertions.rb
+lib/watir/browser.rb
+lib/watir/browsers.rb
+lib/watir/exceptions.rb
+lib/watir/matches.rb
+lib/watir/options.rb
+lib/watir/testcase.rb
+lib/watir/waiter.rb

data/README.txt

@@ -0,0 +1,48 @@
+= watir-common
+
+* FIX (url)
+
+== DESCRIPTION:
+
+Common code used by Watir and FireWatir
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* sudo gem install watir-common
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Bret Pettichord
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'hoe'
+require './lib/watir-common.rb'
+
+Hoe.new('commonwatir', WatirCommon::VERSION) do |p|
+  p.rubyforge_name = 'wtr'
+  p.developer('Bret Pettichord', 'bret@watircraft.com')
+  p.extra_deps << 'user-choices'
+end

data/lib/watir-common.rb

@@ -0,0 +1,3 @@
+class WatirCommon
+  VERSION = '1.6.2'
+end

data/lib/watir.rb

@@ -0,0 +1,6 @@
+# The 'watir' library loads the common watir code, common to all watir
+# implementations. The 'watir/browser' library will autoload the actual
+# implementations.
+
+require 'watir/waiter'
+require 'watir/browser'

data/lib/watir/assertions.rb

@@ -0,0 +1,44 @@
+require 'test/unit/assertions'
+
+module Watir
+  # Verification methods
+  module Assertions
+  include Test::Unit::Assertions
+    
+    # Log a failure if the boolean is true. The message is the failure
+    # message logged.
+    # Whether true or false, the assertion count is incremented.
+    def verify boolean, message = 'verify failed.'
+      add_assertion
+      add_failure message.to_s, caller unless boolean
+    end
+    
+    def verify_equal expected, actual, message=nil
+      full_message = build_message(message, <<EOT, expected, actual)
+<?> expected but was
+<?>.
+EOT
+      verify(expected == actual, full_message)
+    end
+    def verify_match pattern, string, message=nil
+      pattern = case(pattern)
+      when String
+        Regexp.new(Regexp.escape(pattern))
+      else
+        pattern
+      end
+      full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
+      verify(string =~ pattern, full_message)
+    end
+    
+  end
+
+end
+module Test::Unit::Assertions
+    def assert_false(boolean, message=nil)
+        _wrap_assertion do
+            assert_block("assert should not be called with a block.") { !block_given? }
+            assert_block(build_message(message, "<?> is not false.", boolean)) { !boolean }
+        end
+    end
+end 

data/lib/watir/browser.rb

@@ -0,0 +1,130 @@
+# watir/browser
+require 'watir/options'
+module Watir
+  
+=begin rdoc
+
+Watir is a family of open-source drivers for automating web browsers. You
+can use it to write tests that are easy to read and maintain. 
+
+Watir drives browsers the same way people do. It clicks links, fills in forms,
+presses buttons. Watir also checks results, such as whether expected text 
+appears on a page.
+
+The Watir family currently includes support for Internet Explorer (on Windows),
+Firefox (on Windows, Mac and Linux) and Safari (on Mac). 
+
+Project Homepage: http://wtr.rubyforge.org
+
+This Browser module provides a generic interface
+that tests can use to access any browser. The actual browser (and thus
+the actual Watir driver) is determined at runtime based on configuration
+settings.
+
+  require 'watir'
+  browser = Watir::Browser.new
+  browser.goto 'http://google.com'
+  browser.text_field(:name, 'q').set 'pickaxe'  
+  browser.button(:name, 'btnG').click
+  if browser.text.include? 'Programming Ruby'
+    puts 'Text was found'
+  else
+    puts 'Text was not found'
+  end
+
+A comprehensive summary of the Watir API can be found here
+http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
+
+There are two ways to configure the browser that will be used by your tests.
+
+One is to set the +watir_browser+ environment variable to +ie+ or +firefox+. 
+(How you do this depends on your platform.)
+
+The other is to create a file that looks like this.
+
+  browser: ie
+
+And then to add this line to your script, after the require statement and 
+before you invoke Browser.new.
+
+  Watir.options_file = 'path/to/the/file/you/just/created'
+
+=end rdoc
+  
+  module Browser
+    @@browser_classes = {}
+    @@sub_options = {}
+    @@default = nil
+    class << self
+
+      # Create a new instance of a browser driver, as determined by the
+      # configuration settings. (Don't be fooled: this is not actually 
+      # an instance of Browser class.)
+      def new
+        set_sub_options
+        klass.new
+      end
+      # Create a new instance as with #new and start the browser on the
+      # specified url.
+      def start url
+        set_sub_options
+        klass.start url
+      end
+      def klass
+        key = Watir.options[:browser]
+        eval @@browser_classes[key] # this triggers the autoload
+      end
+      private :klass
+      # Add support for the browser option, using the specified class, 
+      # provided as a string. Optionally, additional options supported by
+      # the class can be specified as an array of symbols. Options specified
+      # by the user and included in this list will be passed (as a hash) to 
+      # the set_options class method (if defined) before creating an instance.
+      def support hash_args
+        option = hash_args[:name]
+        class_string = hash_args[:class]
+        additional_options = hash_args[:options]
+        library = hash_args[:library]
+        gem = hash_args[:gem] || library
+
+        @@browser_classes[option] = class_string        
+        @@sub_options[option] = additional_options
+
+        autoload class_string, library
+        activate_gem gem, option
+      end
+      def autoload class_string, library
+        mod, klass = class_string.split('::')
+        eval "module ::#{mod}; autoload :#{klass}, '#{library}'; end"
+      end
+      # Activate the gem (if installed). The default browser will be set
+      # to the first gem that activates.
+      def activate_gem gem_name, option
+        begin
+          gem gem_name 
+          @@default ||= option
+        rescue Gem::LoadError
+        end
+      end
+      def default
+        @@default
+      end
+      # Specifies a default browser. Must be specified before options are parsed.
+      def default= option
+        @@default = option
+      end
+      def options
+        @@browser_classes.keys
+      end
+      def set_sub_options
+        return unless defined?(klass.set_options)
+        sub_options = @@sub_options[Watir.options[:browser]]
+        specified_options = Watir.options.reject {|k, v| !sub_options.include? k}
+        klass.set_options specified_options
+      end
+    end
+  end
+
+end
+
+require 'watir/browsers'

data/lib/watir/browsers.rb

@@ -0,0 +1,12 @@
+# watir/browsers
+# Define browsers supported by Watir
+
+Watir::Browser.support :name => 'ie', :class => 'Watir::IE', 
+  :library => 'watir/ie', :gem => 'watir', 
+  :options => [:speed, :visible]
+
+Watir::Browser.support :name => 'firefox', :class => 'FireWatir::Firefox',
+  :library => 'firewatir'
+
+Watir::Browser.support :name => 'safari', :class => 'Watir::Safari',
+  :library => 'safariwatir'

data/lib/watir/exceptions.rb

@@ -0,0 +1,48 @@
+module Watir
+  module Exception
+
+    # Root class for all Watir Exceptions
+    class WatirException < RuntimeError  
+        def initialize(message="")
+            super(message)
+        end
+    end
+    
+    # This exception is thrown if an attempt is made to access an object that doesn't exist
+    class UnknownObjectException < WatirException; end
+    # This exception is thrown if an attempt is made to access an object that is in a disabled state
+    class ObjectDisabledException   < WatirException; end
+    # This exception is thrown if an attempt is made to access a frame that cannot be found 
+    class UnknownFrameException< WatirException; end
+    # This exception is thrown if an attempt is made to access a form that cannot be found 
+    class UnknownFormException< WatirException; end
+    # This exception is thrown if an attempt is made to access an object that is in a read only state
+    class ObjectReadOnlyException  < WatirException; end
+    # This exception is thrown if an attempt is made to access an object when the specified value cannot be found
+    class NoValueFoundException < WatirException; end
+    # This exception gets raised if part of finding an object is missing
+    class MissingWayOfFindingObjectException < WatirException; end
+    # this exception is raised if an attempt is made to  access a table cell that doesnt exist
+    class UnknownCellException < WatirException; end
+    # This exception is thrown if the window cannot be found
+    class NoMatchingWindowFoundException < WatirException; end
+    # This exception is thrown if an attemp is made to acces the status bar of the browser when it doesnt exist
+    class NoStatusBarException < WatirException; end
+    # This exception is thrown if an http error, such as a 404, 500 etc is encountered while navigating
+    class NavigationException < WatirException; end
+    # This exception is raised if a timeout is exceeded
+    class TimeOutException < WatirException
+      def initialize(duration, timeout)
+        @duration, @timeout = duration, timeout
+      end 
+      attr_reader :duration, :timeout
+    end
+
+    # Return an error message for when unable to locate the element
+    def self.message_for_unable_to_locate(how, what)
+      result = "using #{how.inspect}"
+      result << ", #{what.inspect}" if what
+      "Unable to locate element, #{result}"
+    end    
+  end
+end

data/lib/watir/matches.rb

@@ -0,0 +1,17 @@
+class String
+  def matches(x)
+    return self == x
+  end
+end
+
+class Regexp
+  def matches(x)
+    return self.match(x)
+  end
+end
+
+class Integer
+  def matches(x)
+    return self == x
+  end
+end

data/lib/watir/options.rb

@@ -0,0 +1,51 @@
+# watir/options
+
+require 'user-choices'
+
+module Watir
+  @@options_file = nil
+  @@options = nil
+  class << self
+    # Specify the location of a yaml file containing Watir options. Must be
+    # specified before the options are parsed.
+    def options_file= file
+      @@options_file = file
+    end
+    def options_file
+      @@options_file
+    end
+    def options= x
+      @@options = x
+    end
+    # Return the Watir options, as a hash. If they haven't been parsed yet,
+    # they will be now.
+    def options
+      @@options ||= Watir::Options.new.execute
+    end
+  end
+
+  class Options < UserChoices::Command
+    include UserChoices
+    def add_sources builder
+      builder.add_source EnvironmentSource, :with_prefix, 'watir_'
+      if Watir.options_file
+        builder.add_source YamlConfigFileSource, :from_complete_path, 
+          Watir.options_file
+      end
+    end
+    def add_choices builder
+      builder.add_choice :browser, 
+      :type => Watir::Browser.options, 
+      :default => Watir::Browser.default
+      builder.add_choice :speed, 
+      :type => ['slow', 'fast', 'zippy'], 
+      :default => 'fast'
+      builder.add_choice :visible,
+      :type => :boolean
+    end
+    def execute 
+      @user_choices[:speed] = @user_choices[:speed].to_sym
+      @user_choices
+    end 
+  end
+end

data/lib/watir/testcase.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'watir/assertions'
+
+module Watir
+
+  class TestCase < Test::Unit::TestCase
+    include Watir::Assertions
+    @@order = :sequentially
+    def initialize name
+      throw :invalid_test if name == :default_test && self.class == Watir::TestCase
+      super
+    end        
+    class << self
+      attr_accessor :test_methods, :order
+      def test_methods
+        @test_methods ||= []
+      end
+      def order
+        @order || @@order
+      end
+      def default_order= order
+        @@order = order
+      end
+      def sorted_test_methods
+        case order
+        when :alphabetically then          test_methods.sort
+        when :sequentially then            test_methods
+        when :reversed_sequentially then   test_methods.reverse
+        when :reversed_alphabetically then test_methods.sort.reverse
+        else raise ArgumentError, "Execute option not supported: #{@order}"
+        end
+      end
+      def suite
+        suite = Test::Unit::TestSuite.new(name)
+        sorted_test_methods.each do |test|
+          catch :invalid_test do
+            suite << new(test)
+          end
+        end
+        if (suite.empty?)
+          catch :invalid_test do
+            suite << new(:default_test)
+          end
+        end
+        return suite
+      end
+      def method_added id
+        name = id.id2name
+        test_methods << name if name =~ /^test./
+      end
+      def execute order
+        @order = order
+      end
+    end
+    public :add_assertion
+  end    
+
+end  

data/lib/watir/waiter.rb

@@ -0,0 +1,92 @@
+require 'watir/exceptions'
+
+module Watir
+  
+  def wait_until(*args)
+    Waiter.wait_until(*args) {yield}
+  end  
+
+class TimeKeeper
+  attr_reader :sleep_time
+  def initialize 
+    @sleep_time = 0.0
+  end
+  def sleep seconds
+    @sleep_time += Kernel.sleep seconds    
+  end
+  def now
+    Time.now
+  end
+end
+
+class Waiter
+  # This is an interface to a TimeKeeper which proxies
+  # calls to "sleep" and "Time.now".
+  # Useful for unit testing Waiter.
+  attr_accessor :timer
+
+  # How long to wait between each iteration through the wait_until
+  # loop. In seconds.
+  attr_accessor :polling_interval
+
+  # Timeout for wait_until.
+  attr_accessor :timeout
+  
+  @@default_polling_interval = 0.5
+  @@default_timeout = 60.0
+
+  def initialize(timeout=@@default_timeout,
+                 polling_interval=@@default_polling_interval)
+    @timeout = timeout
+    @polling_interval = polling_interval
+    @timer = TimeKeeper.new
+  end
+
+  # Execute the provided block until either (1) it returns true, or
+  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+  # a TimeOutException will be raised. The block will always
+  # execute at least once.  
+  # 
+  # waiter = Waiter.new(5)
+  # waiter.wait_until {puts 'hello'}
+  # 
+  # This code will print out "hello" for five seconds, and then raise a 
+  # Watir::TimeOutException.
+  def wait_until # block
+    start_time = now
+    until yield do
+      if (duration = now - start_time) > @timeout
+        raise Watir::Exception::TimeOutException.new(duration, @timeout),
+          "Timed out after #{duration} seconds."
+      end
+      sleep @polling_interval
+    end
+  end  
+
+  # Execute the provided block until either (1) it returns true, or
+  # (2) the timeout (in seconds) has been reached. If the timeout is reached,
+  # a TimeOutException will be raised. The block will always
+  # execute at least once.  
+  # 
+  # Waiter.wait_until(5) {puts 'hello'}
+  # 
+  # This code will print out "hello" for five seconds, and then raise a 
+  # Watir::TimeOutException.  
+
+  # IDEA: wait_until: remove defaults from Waiter.wait_until
+  def self.wait_until(timeout=@@default_timeout,
+                      polling_interval=@@default_polling_interval)
+    waiter = new(timeout, polling_interval)
+    waiter.wait_until { yield }
+  end
+     
+  private
+  def sleep seconds
+    @timer.sleep seconds
+  end
+  def now
+    @timer.now
+  end
+end  
+    
+end # module

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: commonwatir
+version: !ruby/object:Gem::Version 
+  version: 1.6.2
+platform: ruby
+authors: 
+- Bret Pettichord
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-06 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: user-choices
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: Common code used by Watir and FireWatir
+email: 
+- bret@watircraft.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/watir.rb
+- lib/watir-common.rb
+- lib/watir/assertions.rb
+- lib/watir/browser.rb
+- lib/watir/browsers.rb
+- lib/watir/exceptions.rb
+- lib/watir/matches.rb
+- lib/watir/options.rb
+- lib/watir/testcase.rb
+- lib/watir/waiter.rb
+has_rdoc: true
+homepage: FIX (url)
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: wtr
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Common code used by Watir and FireWatir
+test_files: []
+