marekj-watirloo 0.0.2

data/History.txt

@@ -0,0 +1,19 @@
+== 0.0.2 2009-02-03
+
+* implement radio_group and checkbox_group for IE and Firefox
+  * Create RadioGroup and CheckboxGroup class for Watir::IE and FireWatir::Firefox
+  * update tests to run for both browsers unchanged.
+  
+== 0.0.1 2008-12-22
+
+* initial merge with newgem generated structure to make it a gem
+  * Patches to Watir and Firewatir
+  * radio_group method added to Watir (not to FireWatir yet)
+  * patch fof Firefox.attach to just attach to the latest window without starting new ff win.
+* tests
+  * built with intent to run unchanged on IE and Firefox
+  * tests run on test/spec gem
+
+== 0.0.0 
+
+* start collecting ideas about building an abstratction layer based on semantic domain model vocabulary customers speak.

data/Manifest.txt

@@ -0,0 +1,36 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile.rb
+lib/watirloo
+lib/watirloo.rb
+lib/watirloo/firewatir_ducktape.rb
+lib/watirloo/reflector.rb
+lib/watirloo/watir_ducktape.rb
+script/console
+script/console.cmd
+script/destroy
+script/destroy.cmd
+script/generate
+script/generate.cmd
+script/reflect.rb
+test/checkbox_group_test.rb
+test/checkboxes_value_test.rb
+test/firewatir
+test/firewatir/attach_instance_test.rb
+test/html
+test/html/census.html
+test/html/checkbox_group1.html
+test/html/labels.html
+test/html/person.html
+test/html/radio_group.html
+test/html/select_lists.html
+test/label_test.rb
+test/person_def_wrappers_test.rb
+test/radio_group_test.rb
+test/select_list_as_face_test.rb
+test/select_list_options_test.rb
+test/select_lists_test.rb
+test/test_helper.rb
+test/text_fields_test.rb
+watirloo.gemspec

data/README.rdoc

@@ -0,0 +1,104 @@
+= Watirloo
+
+* http://watirloo.testr.us
+
+== DESCRIPTION:
+
+Watir Framework and Helper based on Semantic Page Objects Modeling. 
+Helps you design tests expressing DOM elements and groups of elements 
+on the page as Semantic Page Objects rather than their DOM implementations.
+It is not a DSL but it helps you write human readable tests and hooks them up 
+to Watir browsers for implementation
+
+Give it a try. You will like it.
+
+== FEATURES/PROBLEMS:
+
+* Watirloo::Page acts as an adapter with customer facing semantic names for page objects and developer facing implamention talking to the browser.
+* Page creates an abstraction adapter: Human Readable and Machine Executable.
+* Pages contain faces; page objects that are named with semantic intent
+* Best to work with one browser instance on the desktop.
+* Patches Watir and Firewatir to ease testing
+* groups radios in radio_group and checkboxes in checkbox_group and acts each group as page object
+
+== SYNOPSIS:
+
+By convention Watirloo::Page.new attaches itself to the existing IE browser instance on the desktop.
+
+Example: Given a page with text fields for last name and first name we want to enter name 'Kurt Vonnegut'
+You can define hash with key as semantic name and value as watir implementation
+
+  page = Watirloo::Page.new
+  page.add_face :last => [:text_field, :name, 'l_nm'],
+  	:first => [:text_field, :name, 'f_nm']
+  page.last.set "Vonnegut"
+  page.first.set "Kurt"
+
+Or you can create a wrapper method that delegates to the browser
+  
+  class Person < Watirloo::Page
+    def last
+      @b.text_field(:name, 'lnm')
+    end
+    def first
+      @b.text_field(:name, 'fnm')
+    end
+  end
+  
+Or define a hash where key will match the defined faces to be set
+  params = {:first => 'Kurt', :last => 'Vonnegut'}
+  page = Watirloo::Page.new.spray params
+  
+Or pass page cofiguration in the block at page creation
+  
+  page = Person.new do
+    last.set 'Vonnegut'
+    first.set 'Kurt'
+  end
+ 
+  
+== REQUIREMENTS:
+
+* watir >= 1.6.2 runs on IE by default
+* firewatir >= 1.6.2 if you want to use Firefox
+* test/spec gem if you want to run tests
+* newgem and hoe for dev
+
+== INSTALL:
+
+* gem install watirloo
+
+=== ROADMAP
+
+Towards version 0.0.2
+
+* make Watirloo agnostic to browser IE or Firefox or Safari
+* make tests run on IE, Firefox, Safari with the same interface
+* create radio_group to behave like select list and checkbox_group like multi select list
+* build UseCase class as template for scenario based execution of tests for exploratory testing
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 marekj
+
+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.rb

@@ -0,0 +1,59 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/watirloo'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('watirloo', Watirloo::VERSION) do |p|
+  p.developer('marekj', 'marekj.com@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_deps         = [
+    ['watir','>= 1.6.2'],
+   ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"],
+    ['test/spec', '>=0.9.0']
+  ]
+  p.test_globs  =['test/*_test.rb']
+  p.testlib = ['test/spec']
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+desc "run all tests on IE."
+task :test_ie do
+  # all tests use attach method to a browser that exit on the desktop
+  # open new ie browser
+  Watir::Browser.default = 'ie'
+  Watir::Browser.new
+  Watirloo::BrowserHerd.target = :ie
+  tests = Dir["test/*_test.rb"]
+  tests.each do |t|
+    require t
+  end
+  # at the end of test you will have one extra browser
+end
+
+
+desc "run all tests on Firefox (config per FireWatir gem)"
+task :test_ff do
+ # all tests attach to an existing firefox browser
+ # start browser with jssh option
+  Watir::Browser.default='firefox'
+  Watir::Browser.new
+  tests = Dir["test/*_test.rb"]
+  tests.each do |t|
+    Watirloo::BrowserHerd.target = :firefox
+    require t
+  end
+  # at the end of test you will have one extra browser
+end
+
+
+
+

data/lib/watirloo.rb

@@ -0,0 +1,113 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'watirloo/watir_ducktape'
+require 'watirloo/reflector'
+
+module Watirloo
+
+  VERSION = '0.0.2' # Jan2009
+  
+  # Generic Semantic Test Object
+  module TestObject
+    attr_accessor :id, :desc
+  
+  end
+
+  # browser. we return IE or Firefox. Safari? Other Browser?
+  class BrowserHerd 
+    include TestObject
+    
+    @@target = :ie #default target
+
+    def self.target=(indicator)
+      @@target = indicator
+    end
+    
+    def self.target
+      @@target
+    end
+    
+    #provide browser
+    def self.browser
+      case @@target
+      when :ie 
+        Watir::IE.attach :url, // #this attach is a crutch
+      when :firefox
+        require 'watirloo/firewatir_ducktape'
+        # this is a cruch for quick work with pages.
+        # in reality you want to create a browser and pass it as argument to initialize Page class
+        FireWatir::Firefox.attach #this attach is a crutch
+      end
+    end
+  end
+  
+  # Semantic Page Objects Container.
+  # page objects are defined as faces of a Page.
+  # Each face (aka Interface of a page) is accessed by page.facename or page.face(:facename) methods
+  # Pages make Watir fun
+  class Page
+    
+    include TestObject
+    attr_accessor :b
+    attr_reader :faces
+
+    # by convention the Page just attaches to the first available browser.
+    # the smart thing to do is to manage browsers existence on the desktop separately
+    # and supply Page class with the instance of browser you want for your tests.
+    # &block is the convenience at creation time to do some work.
+    # example:
+    #   browser = Watir::start("http://mysitetotest")
+    #   page = Page.new(browser) # specify browser instance to work with or
+    #   page = Page.new # just let the page do lazy thing and attach itself to browser.
+    # part of this page initialization is to provide a convenience while developing tests where
+    # we may have only one browser open and that's the one browser were we want to talk to.
+    def initialize(browser = Watirloo::BrowserHerd.browser , &blk)
+      @b = browser
+      @faces = {}
+      instance_eval(&blk) if block_given? # allows the shortcut to do some work at page creation
+    end
+  
+    # enter values on controls idenfied by keys on the page.
+    # data map is a hash, key represents the page object,
+    # value represents its value to be set, either text, array or boolean
+    def spray(dataMap)
+      dataMap.each_pair do |face_symbol, value|
+        get_face(face_symbol).set value #make every element in the dom respond to set to set its value
+      end
+    end
+  
+    # return Watir object given by its semantic face symbol name
+    def get_face(face_symbol)
+      if self.respond_to? face_symbol # if there is a defined wrapper method for page element provided
+        return self.send(face_symbol) 
+      elsif @faces.member?(face_symbol) # pull element from @faces and send to browser
+        method, *args = @faces[face_symbol] # return definition for face consumable by browser
+        return @b.send(method, *args)
+      else
+        #??? I ran out of ideas
+        raise ::Watir::Exception::WatirException, 'I ran out of ideas in Watirloo'
+      end
+    end
+    alias face get_face
+  
+    # add face definition to page
+    def add_face(definitions)
+      if definitions.kind_of?(Hash)
+        @faces.update definitions  
+      end
+    end
+  
+    # Delegate execution to browser if no method or face defined on page class
+    def method_missing method, *args
+      if @b.respond_to? method
+        @b.send method, *args
+      elsif  @faces.member?(method.to_sym)
+        get_face(method.to_sym)
+      else
+        raise ::Watir::Exception::WatirException, 'I ran out of ideas in Watirloo'
+      end
+    end
+  end
+
+end

data/lib/watirloo/firewatir_ducktape.rb

@@ -0,0 +1,194 @@
+gem 'firewatir', '>=1.6.2' # dependency
+require 'firewatir'
+
+module FireWatir
+  
+  # duck punch and ducktape Firefox for Watirloo needs
+  # some of it is cosmetic surgery and some new methods with intention of
+  # sending a patch to Watir maintainers
+  class Firefox
+    
+    # attach to the existing Firefox that was already started with JSSH option.
+    # this is a hack for Watirloo. it only attaches to the latest firefox.
+    # it assumes there is only one instance of FF window open on the desktop
+    def self.attach
+      Firefox.new :attach => true
+    end
+    
+    # add option key :attach as a hack
+    # :attach => true to attach to topmost window in getWindows().lenght-1
+    # split up initialize to conditionally start FireFox
+    def initialize(options = {})
+      _start_firefox(options) unless options[:attach]
+      set_defaults()
+      get_window_number()
+      set_browser_document()
+    end
+    
+    # refactor initialize method to move all starting of FF into its own method
+    def _start_firefox(options)
+      if(options.kind_of?(Integer))
+        options = {:waitTime => options}
+      end
+      
+      if(options[:profile])
+        profile_opt = "-no-remote -P #{options[:profile]}"
+      else
+        profile_opt = ""
+      end
+      
+      waitTime = options[:waitTime] || 2
+      
+      case RUBY_PLATFORM 
+      when /mswin/
+        # Get the path to Firefox.exe using Registry.
+        require 'win32/registry.rb'
+        path_to_bin = ""
+        Win32::Registry::HKEY_LOCAL_MACHINE.open('SOFTWARE\Mozilla\Mozilla Firefox') do |reg|
+          keys = reg.keys
+          reg1 = Win32::Registry::HKEY_LOCAL_MACHINE.open("SOFTWARE\\Mozilla\\Mozilla Firefox\\#{keys[0]}\\Main")
+          reg1.each do |subkey, type, data|
+            if(subkey =~ /pathtoexe/i)
+              path_to_bin = data
+            end
+          end
+        end
+        
+      when /linux/i
+        path_to_bin = `which firefox`.strip
+      when /darwin/i
+        path_to_bin = '/Applications/Firefox.app/Contents/MacOS/firefox'
+      when /java/
+        raise "Not implemented: Create a browser finder in JRuby"
+      end
+      
+      @t = Thread.new { system("#{path_to_bin} -jssh #{profile_opt}")}   
+      sleep waitTime
+      
+    end
+    private :_start_firefox
+
+  end
+
+  class SelectList
+    
+    include Watir::SelectListCommonWatir
+    
+        # accepts one text item or array of text items. if array then sets one after another. 
+    # For single select lists the last item in array wins
+    # 
+    # examples
+    #   select_list.set 'bla' # => single option text
+    #   select_list.set ['bla','foo','gugu'] # => set 3 options by text. If 
+    #       this is a single select list box it will set each value in turn
+    #   select_list set 1 # => set the first option in a list
+    #   select_list.set [1,3,5] => set the first, third and fith options
+    def set(item)
+      _set(:text, item)
+    end
+
+    # set item by the option value attribute. if array then set one after anohter.
+    # see examples in set method
+    def set_value(value)
+      _set(:value, value)
+    end
+    
+    # returns array of value attributes
+    # each option usually has a value attribute 
+    # which is hidden to the person viewing the page
+    def values
+      a = []
+      items.each do |item|
+        a << option(:text, item).value
+      end
+      return a
+    end
+    
+    alias clear clearSelection
+    
+    # alias, items or contents return the same visible text items
+    alias items getAllContents
+    
+  end
+
+  # RadioGroup and CheckboxGroup common behaviour
+  module RadioCheckGroup
+    
+    include Watir::RadioCheckGroupCommonWatir
+
+    def values
+      values = []
+      @o.each {|thing| values << thing.value}
+      return values
+    end
+    
+    def get_by_value value
+      if values.member? value
+        @o.find {|thing| thing.value == value}
+      else
+        raise ::Watir::Exception::WatirException, "value #{value} not found in hidden values"
+      end
+    end
+  end
+  
+  class CheckboxGroup
+    
+    include RadioCheckGroup
+    include Watir::CheckboxGroupCommonWatir
+    
+    def initialize(container, name)
+      @container = container
+      @name = name
+      @o = []
+      @container.checkboxes.each do |cb| #TODO find why find_all does not work
+        if cb.name == @name
+          @o << cb
+        end
+      end
+    end
+    
+    # which values are selected?
+    def selected_values
+      values = []
+      selected_checkboxes.each do |cb|
+        values << cb.value
+      end
+      return values
+    end
+  end
+  
+  class RadioGroup
+    
+    include RadioCheckGroup
+    include Watir::RadioGroupCommonWatir
+    
+    def initialize(container, name)
+      @container = container
+      @name = name
+      @o = []
+      @container.radios.each do |r| #TODO find why find_all does not work
+        if r.name == @name
+          @o << r
+        end
+      end
+      return @o
+    end
+    
+    # see Watir::RadioGroup.selected_value
+    def selected_value
+      selected_radio.value
+    end
+    alias selected selected_value
+  end
+  
+  
+  module Container
+    def radio_group(name)
+      RadioGroup.new(self, name)
+    end
+    
+    def checkbox_group(name)
+      CheckboxGroup.new(self, name)
+    end
+  end
+end