marekj-watirloo 0.0.3 → 0.0.5

data/lib/watirloo/browsers.rb

@@ -0,0 +1,73 @@
+module Watirloo
+
+  # This is 'opinionated' method.
+  # The way I work with browsers is this:
+  # I save the current handle of the browser (ie.hwnd) to the storage yaml file so I can reattach to the same
+  # browser later. Basically in exploratory testing I don't want to start and close browsers. I want to maintain
+  # reference to one (or more) browsers and I have nicknames for them.
+  # on restart of tests useing Watirloo I reuse the browser. If the browser is not there I just start a new browser which
+  # will from now on become my new 'default' test session browser.
+  # In Case of Firefox I attach to the 'one' existing firefox or a start a new one.
+  # So this method either attaches to one that's there or it starts a new one and puts it in Browsers::Storage
+  # this way of working with browsers is opinionated I think.
+  # if you want you can just use Watir::IE.start and reuse that browsers for tests. This here is a convenience method
+  def self.browser(key = 'default')
+    case Browsers.target
+    when :ie then Browsers.ie key
+    when :firefox then Browsers.ff
+    end
+  end
+
+  # manage references to browsers. Currently IE or Firefox.
+  # Safari? Other Browser? not yet
+  module Browsers
+
+    @@target = :ie #by default we talk to IE on Windows.
+    @@targets = [:ie, :firefox]
+
+    class << self
+
+      # set and get the target. by default we talk to :ie.
+      def target
+        return @@target
+      end
+
+      def target=(indicator)
+        if @@targets.include? indicator
+          @@target = indicator
+        else
+          raise Exception, "target indicator #{indicator} is not valid: use :ie or :firefox"
+        end
+      end
+
+
+      # provides browser instance to client.
+      # attaches to the existing 'default' test session browser on the desktop
+      # By convention the mental model here is that we are working
+      # with one browser on the desktop. This is how a person would typically work
+      def ie(key='default')
+        begin
+          Locker.browser key
+        rescue => e #XXX it's probably a bad practice to use exception for logic control
+          # TODO logger here
+          ie = Watir::IE.start
+          sleep 3
+          Locker.add(ie, key)
+          ie #return newly created browser for the test session and store it for laterusage
+        end
+      end
+
+      def ff
+        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
+        begin
+          FireWatir::Firefox.attach #this attach is a crutch
+        rescue
+          puts 'got to start browser ff dude'
+        end
+
+      end
+    end
+  end
+end

data/lib/watirloo/desktop.rb

@@ -0,0 +1,44 @@
+module Watirloo
+
+  # The browser desktop manager
+  # checks to see what browsers already exist on the dekstop.
+  # compares what is on the desktop to what was there last time
+  module Desktop
+
+    class << self
+
+      # returns browser windows found on the desktop
+      def browsers
+        brs =[]
+        Watir::IE.each {|ie| brs << ie }
+        brs
+      end
+
+      # return handles of Browsers found on desktop
+      def hwnds
+        hs =[]
+        browsers.each {|ie| hs << ie.hwnd}
+        hs
+      end
+
+      # returns handles for browsers that appeared on Desktop since the last scan for browsers
+      def additions(known_hwnds)
+        hwnds.select {|h| !known_hwnds.include?(h)}
+      end
+
+      # returns handles for browsers no longer found on the Desktop since the last scan for browsers
+      def deletions(known_hwnds)
+        known_hwnds.select {|h| !hwnds.include?(h)}
+      end
+
+      # Closes all the browsers on the desktop.
+      # Creats a known clear slate where no browsers exist
+      def clear
+        Watir::IE.each {|ie| ie.close}
+        sleep 3
+        raise Exception, "Failed to clear all the browsers from the desktop" unless browsers.empty?
+      end
+
+    end
+  end
+end

data/lib/watirloo/extension/object.rb

@@ -0,0 +1,26 @@
+
+# see this;http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html
+# instance_exec is used for face methods
+if VERSION <= '1.8.6'
+  class Object
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    # instance_exec method evaluates a block of code relative to the specified object, with parameters whom come from outside the object.
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end

data/lib/watirloo/{watir_ducktape.rb → extension/watir_ducktape.rb}

@@ -59,13 +59,13 @@ module Watir
        
     def values
       opts = []
-      @o.each {|r| opts << r.ole_object.invoke('value')}
+      @o.each {|rc| opts << rc.ole_object.invoke('value')}
       return opts
     end
     
     def get_by_value value
       if values.member? value
-        @o.find {|r| r.ole_object.invoke('value') == value}
+        @o.find {|rc| rc.ole_object.invoke('value') == value}
       else
         raise ::Watir::Exception::WatirException, "value #{value} not found in hidden_values"
       end
@@ -93,6 +93,14 @@ module Watir
     def selected_radio
       @o.find {|r| r.isSet?}
     end
+
+    # if a radio button in a group is set then the group is set
+    # by default it should be set but many HTML implementations provide
+    # the radiogroup to the user with no default one set (Bad practice perhaps)
+    def set?
+      selected_radio ? true : false
+    end
+
   end
 
   # radios that share the same :name attribute form a RadioGroup. 
@@ -118,11 +126,30 @@ module Watir
     include RadioCheckGroup
     include RadioGroupCommonWatir
     
-    def initialize(container, name)
+    def initialize(container, how, what)
       @container = container
-      @name = name
-      @o = @container.radios.find_all {|r| r.name == @name}
+      @how = how
+      @what = what
+      @o = locate
+    end
+    
+    def name
+      @name
+    end
+    
+    def locate
+      @name = case @how
+      when :name then @what
+      when :index then
+        names = []
+        @container.radios.each do |r|
+          names << r.name
+        end
+        names.uniq.at(@what-1) # follow 1-based index addressing for Watir API 
+      end
+      @container.radios.find_all {|r| r.name == @name}
     end
+    private :locate
     
     # which value is selected?. returns value text as string
     # So per HTML401 spec I am not sure if we should ever have empyt array returned here
@@ -138,17 +165,66 @@ module Watir
 
   end
   
+  class TextFields < ElementCollections
+    
+    def reflect
+      ret = []
+      self.each do |item|
+        how, what = get_how_what get_attribs(item)
+        facename = suggest_def_name what
+        value = item.value
+        # this approach relies on doc element
+        ret << "face(:#{facename}) {doc.text_field(:#{how}, #{what.inspect})}"
+        ret << "#{facename}.value.should == #{value.inspect}"
+      end
+      ret
+    end
+    
+  end
+  
+  class RadioGroups < ElementCollections
+    
+    def element_class; RadioGroup; end
+    def length
+      names = []
+      @container.radios.each do |r|
+        names << r.name
+      end
+      names.uniq.size #non repeating names
+    end
+    
+    def reflect
+      ret = []
+      self.each do |item|
+        name = item.name
+        facename = suggest_def_name name
+        values = item.values
+        selected = item.selected
+        ret << "face(:#{facename}) {doc.radio_group(#{name.inspect})}"
+        ret << "#{facename}.values.should == #{values.inspect}"
+        ret << "#{facename}.selected.should == #{selected.inspect}"
+      end
+      ret
+    end
+    
+    
+    private
+    def iterator_object(i)
+      @container.radio_group(:index, i + 1)
+    end
+  end
   
   module CheckboxGroupCommonWatir
 
-    # returns selected checkboxex as array
-    # [] = nothing selected
-    # [checkbox, checkbox] = checkboxes that are selected.
+    # returns selected checkboxes as array
+    # when empty [] then nothing is selected
+    # when [checkbox, checkbox] = array of checkboxes that are selected
+    # that you can iterate over for tests.
     def selected_checkboxes
       @o.select {|cb| cb.isSet?}
     end
     
-    # convinience method as a filter for select_values
+    # convenience method as a filter for selected_values
     # returns: 
     #   nil => when no checkbox is set
     #   'value' => if one checkbox is set
@@ -168,6 +244,14 @@ module Watir
     # compare to SelectList where selected returns selected_item
     alias selected selected_value
 
+
+    # if at least one checkbox is selected then the group is considered set
+    def set?
+      (selected_checkboxes != []) ? true : false
+    end
+
+    alias checked? set?
+    
   end
 
   # Checkbox group semantically behaves like multi select list box.
@@ -179,11 +263,30 @@ module Watir
     include RadioCheckGroup
     include CheckboxGroupCommonWatir
     
-    def initialize(container, name)
+    def initialize(container, how, what)
       @container = container
-      @name = name
-      @o = @container.checkboxes.find_all {|cb| cb.name == @name}
+      @how = how
+      @what = what
+      @o = locate
+    end
+    
+    def name
+      @name
+    end
+    
+    def locate
+      @name = case @how
+      when :name then @what
+      when :index then
+        names = []
+        @container.checkboxes.each do |cb|
+          names << cb.name
+        end
+        names.uniq.at(@what-1) # follow 1-based index addressing for Watir API 
+      end
+      @container.checkboxes.find_all {|cb| cb.name == @name}
     end
+    private :locate
     
     # returns array of value attributes. Each Checkbox in a group 
     # has a value which is invisible to the user
@@ -196,15 +299,57 @@ module Watir
     end
   end
 
+  class CheckboxGroups < ElementCollections
+    def element_class; CheckboxGroup; end
+    def length
+      names = []
+      @container.checkboxes.each do |cb|
+        names << cb.name
+      end
+      names.uniq.size #non repeating names
+    end
+    
+    def reflect
+      ret = []
+      self.each do |item|
+        name = item.name
+        facename = suggest_def_name(name)
+        values = item.values
+        selected = item.selected
+        ret << "face(:#{facename}) {doc.checkbox_group(#{name.inspect})}"
+        ret << "#{facename}.values.should == #{values.inspect}"
+        ret << "#{facename}.selected.should == #{selected.inspect}"
+      end
+      ret
+    end
+    
+    private
+    def iterator_object(i)
+      @container.checkbox_group(:index, i + 1)
+    end
+  end
+ 
   
   module Container
-    def radio_group(name)
-      RadioGroup.new(self, name)
+      
+    def radio_group(how, what=nil)
+      how, what = process_default :name, how, what
+      RadioGroup.new(self, how, what)
     end
       
-    def checkbox_group(name)
-      CheckboxGroup.new(self, name)
+    def radio_groups
+      RadioGroups.new(self)
+    end
+    
+    def checkbox_group(how, what=nil)
+      how, what = process_default :name, how, what
+      CheckboxGroup.new(self, how, what)
+    end
+    
+    def checkbox_groups
+      CheckboxGroups.new(self)
     end
+    
   end
   
   class RadioCheckCommon
@@ -372,5 +517,25 @@ module Watir
     # alias, items or contents return the same visible text items
     alias items getAllContents
 
+
+
+    def reflect
+      ret = []
+      self.each do |item|
+        name = item.name
+        facename = suggest_def_name name
+        values = item.values
+        items = item.items
+        selected_item = item.selected_item
+        selected_value = item.selected_value
+
+        ret << "face(:#{facename}) {doc.select_list(:name, #{name.inspect})}"
+        ret << "#{facename}.items.should == #{items.inspect}"
+        ret << "#{facename}.values.should == #{values.inspect}"
+        ret << "#{facename}.selected_item.should == #{selected_item.inspect}"
+        ret << "#{facename}.selected_value.should == #{selected_value.inspect}"
+      end
+      ret
+    end
   end
 end

data/lib/watirloo/extension/watir_reflector.rb

@@ -0,0 +1,83 @@
+=begin rdoc
+Look Ma!, I can Has Reflect The Browser
+
+Watir::Reflector module added to watir. 
+reflect watir element collections. reflections create wrapper methods 
+with suggested semantic naming based on id, name, value or combination. 
+the intention is to create a scaffolding for Watirloo::Page elements.
+=end
+
+module Watir
+  
+  # Watirloo::Page objects scaffold creation. Talks to the current page and reflects
+  # the watir elements to be used for semantic test objects tests.
+  module Reflector
+    
+    #cleanup the def name for some kind of semantic name
+    def suggest_def_name(how)
+      how.gsub!(/_+/,'_') # double underscores to one
+      how.gsub!(/^_/, '') # if it begins with undrscore kill it.
+      how.gsub!(/\s+/, '_') # kill spaces if for some strange reason they exist
+      how.underscore #Any CamelCase will be converted to camel_no_case
+    end
+
+    # glean(:text_fields, [:id, :name, :value]
+    # glean(:radios, [:id, :name, :value])
+    # glean and make a map of types and attributes needed for reflection
+    # this should be private I think
+    def get_attribs(item)
+      attribs = [:id, :name, :value]
+      h = {}
+      attribs.each do |k|
+        v = item.attribute_value k.to_s
+        h[k] = v
+      end
+      h
+    end
+    
+    def get_how_what h
+      how, what = '', ''
+      if h[:id] != '' #First Choice: if id is not blank then we'll use it
+        how, what = :id, h[:id]
+      elsif h[:name] != '' #Second Choice: if name is not blank then we'll use it instead of id
+        how, what = :name, h[:name]
+      elsif h[:value] != ''
+        how, what = :value, h[:value]
+      end
+      [how, what]
+    end
+    
+    # public interface for Reflector.
+    # ie.reflect # => returns object definitions for entire dom using ie as container
+    # ie.frame('main').select_lists.reflect# => returns definitions for select_lists 
+    # only contained by the frame
+    # you can be as granular as needed
+    def reflect
+      puts "I has not exist. Implements me please"
+    end
+  end
+  
+  
+  module Container
+
+    # container asks collections to reflect themselves
+    # each collection knows how to reflect itself and what to reflect
+    def reflect
+      ref = []
+      [:radio_groups, :checkbox_groups, :text_fields, :select_lists].each do |type|
+        ret << self.send(type).reflect
+      end
+      return ref
+    end
+
+  end
+
+
+  class ElementCollections
+
+    # adds reflect method to element collections
+    include ::Watir::Reflector
+
+  end
+
+end