watirloo 0.0.7

data/lib/watirloo/page.rb

@@ -0,0 +1,140 @@
+module Watirloo
+
+  # Semantic Page Objects Container
+  # include it in your ClientClass that manages Test. Your client class must provide an instance of browser.
+  # If you don't want an explicit browser the Watirloo.browser will be used.
+  # example
+  #     class UsageScenarioOfSomeFeature
+  #       include Watirloo::Page
+  #     end
+  # now the client GoogleSearch can access browser and elements defined
+  # instead of including it directly in classes that you instantiate to keep track of state you can build modules of pages
+  # that you can later include into your client
+  module Page
+
+    # provide browser for a client. If now browser is assigned to a client
+    # Use the default Watirloo.browser if no browser set explicitly
+    def browser
+      @browser ||= ::Watirloo.browser
+    end
+
+    # set browser instance for a client to use
+    # --
+    # the method is a bit better than browser= because setting browser in mehtods would probably
+    # requires a call to:
+    #   self.browser= ie
+    # else
+    #   browser = ie
+    # may be an assignemnt to local variable
+    def browser=(browser)
+      @browser = browser
+    end
+
+    # browser document container that delimits the scope of elements.
+    # all faces use page as a base. In a frameless DOM the browser is page, the document container.
+    # however if page with frames you can setup a doc destination to be a frame as the
+    # base container for face accessors.
+    # in most circumstances page is a passthru to browser
+    # example: if you have a frameset and you want to talk to a frame(:name, 'content') you can redefine
+    # set the page
+    # self.page = browser.frame(:name, 'content') see set_page
+    #
+    def page
+      @page ||= browser
+    end
+
+    # set the page base element as the receiver of all facename methods
+    # one would have to make this type of call:
+    #   self.page = watir_element
+    #   else this:
+    #   page = watir_element
+    #   may be treated as assignemnt to local variable
+    #
+    def page=(watir_element)
+      @page = watir_element
+    end
+
+    module ClassMethods
+
+      # "anything which is the forward or world facing part of a system
+      # which has internal structure is considered its 'face', like the facade of a building"
+      # ~  http://en.wikipedia.org/wiki/Face
+      #
+      # Declares Semantic Interface to the DOM elements on the Page (facade) binds a symbol to a block of code that accesses the DOM.
+      # When the user speaks of filling in the last name the are usually entering data in a text_field
+      # we can create a semantic accessor interface like this:
+      #   face(:last_name) { text_field(:name, 'last_nm'}
+      # what matters to the user is on the left (:last_name) and what matters to the programmer is on the right
+      # The face method provides an adapter and insolates the tests form the changes in GUI.
+      # The patterns is: face(:friendlyname) { watir_element(how, whatcode }
+      # where watir_element is actuall way of accessing the element on the page. The page is implicit.
+      # Each interface or face is an object of interest that we want to access by its interface name
+      #   example:
+      #
+      #     class GoogleSearch
+      #       include Watirloo::Page
+      #       face(:query)   { text_field(:name, 'q') }
+      #       face(:search)  { button(:name, 'btnG') }
+      #     end
+      #
+      #     at run time calling
+      #     query.set "Ruby"
+      #     is equivalent to
+      #     page.text_field(:name, 'q').set "Ruby"
+      #     where page is the root of HTML document
+      #
+      def face(name, *args, &definition)
+        define_method(name) do |*args|
+          page.instance_exec(*args, &definition)
+        end
+      end
+
+    end
+
+    # metahook by which ClassMethods become singleton methods of an including module
+    # Perhaps the proper way is to do this
+    # class SomeClass
+    #   include PageHelper
+    #   extend PageHelper::ClassMethods
+    # end
+    # but we are just learning this metaprogramming
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+  
+    # enter values on controls idenfied by keys on the page.
+    # data map is a hash, key represents the page objects that can be filled or set with values,
+    # value represents its value to be set, either text, array or boolean
+    # exmaple: 
+    #     spray :first => "Johnny", :last => 'Begood'
+    #     
+    #     # Given the faces defined
+    #     face(:first) {doc.text_field(:name, 'lst_nm')}
+    #     face(:last) {doc.text_field(:name, 'fst_nm')}
+    def spray(hash)
+      hash.each_pair do |facename, value|
+        self.send(facename).set value #make every control element in watir respond to set
+      end
+    end
+
+    # set values on the page given the interface keys
+    alias set spray
+
+
+    def scrape(facenames)
+      data = {}
+      facenames.each do |facename|
+        watir_control = self.send facename
+        method_name = case watir_control.class.to_s.split("::").last
+        when "SelectList", "CheckboxGroup", "RadioGroup" then :selected
+        else  
+          :value
+        end
+        data.update facename => watir_control.send(method_name)
+      end
+      data
+    end
+
+
+  end
+end

data/lib/watirloo.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'watirloo/extension/object'
+require 'watirloo/extension/watir_ducktape'
+require 'watirloo/extension/watir_reflector'
+require 'watirloo/browsers'
+require 'watirloo/desktop'
+require 'watirloo/locker'
+require 'watirloo/page'
+
+module Watirloo
+  VERSION = '0.0.6' # Jul2009
+
+end
+

data/spec/browser_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Watirloo browser when no browsers on desktop nor in locker" do
+
+  before(:all) do
+    Watirloo::Desktop.clear
+    Watirloo::Locker.clear
+  end
+
+  it "should start a default new browser and load a testfile" do
+    browser = Watirloo.browser
+    browser.should be_kind_of(Watir::IE)
+    browser.goto testfile('person.html')
+  end
+  
+  it 'should attach to a default browser with loaded testfile and return its title' do
+    browser = Watirloo.browser
+    browser.should be_kind_of(Watir::IE)
+    browser.title.should == 'Person'
+  end
+  
+  it "should start second browser with a named keyword" do
+    Watirloo.browser 'second'
+  end
+
+  it 'should attach to second browser with keyword and navigate to a testfile' do
+    browser2 = Watirloo.browser 'second'
+    browser2.goto testfile('census.html')
+  end
+    
+  it 'should attach to two distinct browsers by key values by kewords used to start them' do
+    b2 = Watirloo.browser 'second'
+    b1 = Watirloo.browser 'default'
+    b2.title.should == 'Census'
+    b1.title.should == 'Person'
+  end
+
+end

data/spec/browser_threads_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'thread'
+
+# This is more of an example of using Watirloo::browser() and Watirloo::Locker with threads
+# for multibrowser testing possiblilities
+describe "Watirloo multiple browsers and threads" do
+
+  before(:all) do
+    Watirloo::Desktop.clear
+    Watirloo::Locker.clear
+  end
+
+
+  it "open 5 new browsers in threads and add them to locker"  do
+    threads = []
+    1.upto(5) do |i|
+      threads << Thread.new { Watirloo.browser(i) }
+    end
+    threads.each {|x| x.join}
+  end
+
+  it 'use locker to reattach to 5 browsers and load 5 diff pages at once' do
+    threads = []
+    files = ['census.html', 'labels.html', 'person.html', 'select_lists.html', 'radio_group.html']
+    titles = ['Census', 'Labels', 'Person', 'select lists', "radio_groups"]
+    1.upto(5) do |i|
+      threads << Thread.new do
+        Watirloo.browser(i).goto testfile(files[i-1])
+        sleep 5 #add safety
+        Watirloo.browser(i).title.should == titles[i-1]
+      end
+    end
+    threads.each {|x| x.join}
+  end
+
+  it "reattach and close all 5 browsers" do
+    hwnds = Watirloo::Desktop.hwnds
+    threads =[]
+    1.upto(5) { |i| threads << Thread.new { Watirloo.browser(i).close } }
+    threads.each {|x| x.join}
+    sleep 5 #Ensure browsers close
+    Watirloo::Desktop.deletions(hwnds).size.should == 5
+  end
+end
+

data/spec/checkbox_group_spec.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'browser checkbox_group accesses a group of checkboxes sharing the same name on a page' do
+
+  before :each do
+    @browser = Watirloo::browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+  
+  it 'browser responds to checkbox_group' do
+    @browser.should respond_to(:checkbox_group)
+  end
+  
+  it 'access by name as default returns CheckboxGroup' do
+    if @browser.kind_of?(FireWatir::Firefox)
+      @browser.checkbox_group('pets').should be_kind_of(FireWatir::CheckboxGroup)
+    elsif  @browser.kind_of?(Watir::IE)
+      @browser.checkbox_group('pets').should be_kind_of(Watir::CheckboxGroup)
+    end
+  end
+
+  it 'size retuns checkboxes as items count in a group' do
+    @browser.checkbox_group(:name, 'pets').size.should == 5
+  end
+  
+  it 'values returns array of value attributes for each checkbox in a group' do
+    @browser.checkbox_group('pets').values.should == ["cat", "dog", "zook", "zebra", "wumpa"]
+  end
+
+end
+
+describe "checkbox_group values when no checkbox is checked in a group" do
+
+  before :each do
+    @browser = Watirloo::browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+
+
+  it 'selected should return nil' do
+    @browser.checkbox_group('pets').selected.should be_nil
+  end
+  it 'selected_value should return nil' do
+    @browser.checkbox_group('pets').selected_value.should be_nil
+  end
+  it 'selected_values should return empty array' do
+    @browser.checkbox_group('pets').selected_values.should be_empty
+  end
+
+  it "set? should return false when no checkbox is checked in a group" do
+    @browser.checkbox_group("pets").should_not be_set
+  end
+    
+end
+
+describe "checkbox_group values when set string selecs one item only" do
+
+  before :each do
+    @browser = Watirloo::browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+
+
+  it "selected should return the string used to select it" do
+    @browser.checkbox_group('pets').set 'dog'
+    @browser.checkbox_group('pets').selected.should == 'dog'
+  end
+
+  it "selected_value should return the string when one item is selected" do
+    @browser.checkbox_group('pets').set 'dog'
+    @browser.checkbox_group('pets').selected_value.should == 'dog'
+  end
+
+  it 'selected values returns array with one element' do
+    @browser.checkbox_group('pets').set 'dog'
+    @browser.checkbox_group('pets').selected_values.should == ['dog']
+  end
+
+  it "set? should return truee when 1 checkbox is checked in a group" do
+    @browser.checkbox_group('pets').set 'dog'
+    @browser.checkbox_group("pets").should be_set
+  end
+
+end
+
+
+describe "checkbox_group set array of strings selects multiple values in a group" do
+
+  before :each do
+    @browser = Watirloo::browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+
+
+  it "selected returns array of strings when multiple values are selected" do
+    @browser.checkbox_group('pets').set ['dog', 'zebra', 'cat'] # not in order
+    @browser.checkbox_group('pets').selected.should == ['cat', 'dog', 'zebra']
+  end
+
+  it 'selected_value returns the same array of strings by position in a group' do
+    @browser.checkbox_group('pets').set ['zebra', 'dog', 'cat'] # not in order
+    @browser.checkbox_group('pets').selected_value.should == ['cat', 'dog', 'zebra'] # bypass filter
+  end
+
+  it "selected_values returns the same array of strings by position in a group" do
+    @browser.checkbox_group('pets').set ['cat', 'zebra', 'dog'] # not in order
+    @browser.checkbox_group('pets').selected_values.should == ['cat', 'dog', 'zebra']
+  end
+
+  it "set? should return truee when more than 1 checkbox is checked in a group" do
+    @browser.checkbox_group('pets').set ['cat', 'zebra', 'dog'] # not in order
+    @browser.checkbox_group("pets").should be_set
+  end
+
+end
+
+describe "checkbox_group set by numberical position" do
+
+  before :each do
+    @browser = Watirloo::browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+
+
+  it 'set Fixnum checks checkbox by position in a group. Position is 1 based.' do
+    #Behaves like select by single value
+    @browser.checkbox_group('pets').set 3
+    @browser.checkbox_group('pets').selected_value.should == 'zook'
+  end
+
+  it 'set array of Fixnums checks each checkbox by position' do
+    #behaves like select multiple strings
+    @browser.checkbox_group('pets').set [4,1,2] # not in order
+    @browser.checkbox_group('pets').selected.should == ["cat", "dog", "zebra"]
+  end
+end

data/spec/checkbox_groups_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'checkbox_groups access for browser' do
+
+  before :each do
+    @browser = Watirloo::browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+  
+  it 'browser responds to checkbox_group' do
+    @browser.should respond_to(:checkbox_groups)
+  end
+  
+  it 'returns group object and its values from the page' do
+    @browser.checkbox_groups.should be_kind_of(Watir::CheckboxGroups)
+  end
+
+  it 'lenght returns integer count of groups' do
+    @browser.checkbox_groups.length.should == 4
+  end
+
+  it 'each iterator returns CheckboxGroup' do
+    @browser.checkbox_groups.each do |cbg|
+      cbg.should be_kind_of( Watir::CheckboxGroup )
+    end
+  end
+
+  it 'each accesses the group and returns name' do
+    names =[]
+    @browser.checkbox_groups.each do |cg|
+      names << cg.name
+    end
+    names.should == ['pets', 'singleIndicator', 'petsa', 'singleIndicatora']
+  end
+  
+  it 'bracket access[] returns 1-based indexed group' do
+    @browser.checkbox_groups[1].values.should == %w[cat dog zook zebra wumpa]
+    @browser.checkbox_groups[3].name.should == 'petsa'
+  end
+  
+  it 'if checkbox group does not exists it returns size 0 or name nil (or should it blow up? or respond to exists? method' do
+    @browser.checkbox_groups[6].size.should == 0 # does not exist. let's not blow up. suggestions?
+    @browser.checkbox_groups[6].name.should == nil #suggestions?
+  end
+  
+  it 'return checkbox groups contained by the form element' do
+    @browser.forms[2].checkbox_groups.length.should == 2
+    names =[]
+    @browser.forms[2].checkbox_groups.each do |cbg|
+      names << cbg.name
+    end 
+    names.should == ['petsa', 'singleIndicatora']
+  end
+
+end

data/spec/checkboxes_value_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'setting and getting values for individual checkboxes with value attributes in face definitions' do
+
+  # in watir you have to access each checkbox, we now have checkbox_group for this
+  # in Watirloo you can access CheckboxGroup as shortcut using
+  # :pets => [:checkbox_group, 'pets']
+  include Watirloo::Page
+  face(:pets_cat) { checkbox(:name, 'pets', 'cat') }
+  face(:pets_dog) { checkbox(:name, 'pets', 'dog') }
+  face(:pets_zook) { checkbox(:name, 'pets', 'zook') }
+  face(:pets_zebra) { checkbox(:name, 'pets', 'zebra') }
+  face(:pets_wumpa) { checkbox(:name, 'pets', 'wumpa') }
+  
+  before do
+    browser.goto testfile('checkbox_group1.html')
+  end
+  
+  it 'semantic name accesses individual CheckBox' do
+    if browser.kind_of?(FireWatir::Firefox)
+      pets_cat.should be_kind_of(FireWatir::CheckBox)
+      
+    elsif browser.kind_of?(Watir::IE)
+      pets_cat.should be_kind_of(Watir::CheckBox)
+    end
+  end
+  
+  it 'set individual checkbox does not set other checkboxes sharing the same name' do
+    pets_dog.should_not be_checked
+    pets_dog.set true
+    pets_dog.should be_checked
+    pets_cat.should_not be_checked
+  end
+  
+end

data/spec/desktop_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe "Watirloo Desktop" do
+
+  it "clear closes all browsers on the desktop and browsers should be empty" do
+    Watirloo::Desktop.clear
+    Watirloo::Desktop.browsers.should be_empty
+  end
+
+  it "adding first browser should report 1 addition and no deletions" do
+    hwnds = Watirloo::Desktop.hwnds
+    Watir::IE.start
+    added = Watirloo::Desktop.additions(hwnds)
+    added.size.should == 1
+    Watirloo::Desktop.deletions(hwnds).should be_empty
+  end
+  
+  it 'while one browser on the desktop the additions and deletions should be false' do
+    hwnds = Watirloo::Desktop.hwnds
+    hwnds.size.should == 1
+    Watirloo::Desktop.additions(hwnds).should be_empty
+    Watirloo::Desktop.deletions(hwnds).should be_empty
+  end
+
+  it 'adding second browser should report one addition and no deletions' do
+    hwnds = Watirloo::Desktop.hwnds
+    Watir::IE.start
+    Watirloo::Desktop.additions(hwnds).size.should == 1
+    Watirloo::Desktop.deletions(hwnds).should be_empty
+    Watirloo::Desktop.hwnds.size.should == 2
+  end
+
+  it 'close one should report 1 deletion and no additions, attempt to attach to deleted cause exception' do
+    hwnds = Watirloo::Desktop.hwnds
+    Watirloo::Desktop.browsers[0].close #close any
+    Watirloo::Desktop.additions(hwnds).should be_empty
+    deleted = Watirloo::Desktop.deletions(hwnds)
+    deleted.size.should == 1
+    lambda{ Watir::IE.attach :hwnd, deleted[0]}.should raise_error
+  end
+
+  
+  it "close one and start new one should report one addition and one deletion" do
+    hwnds = Watirloo::Desktop.hwnds
+    hwnds.size.should == 1
+    Watir::IE.start
+    (Watir::IE.attach(:hwnd, hwnds[0])).close
+    sleep 5
+    Watirloo::Desktop.additions(hwnds).size.should == 1
+    Watirloo::Desktop.deletions(hwnds).size.should == 1
+  end
+
+end

data/spec/extra/browser_events_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'observer'
+
+module Watirloo
+
+  # InternetExplorer Object DWebBrowserEvents2 is an Interface for Events.
+  # We can hook into the events and intercept the events we care to catch.
+  # Every time an event we care to watch for occurs the Publisher notifies observers.
+  # Extra: you can also build a publisher that listenes to 'HTMLDocumentEvents2' of ie.ie.document object
+  # and notify listeners to onclick events if you need to
+  # @events_to_publish = %w[BeforeNavigate2 DocumentComplete NavigateError NewWindow3]
+  class BrowserEventsPublisher
+
+    include Observable
+
+    def initialize( ie )
+      @events_to_publish = %w[BeforeNavigate2 DocumentComplete TitleChange NavigateError NewWindow3 OnQuit]
+      @event_sink = WIN32OLE_EVENT.new( ie.ie, 'DWebBrowserEvents2' )
+    end
+
+    def run
+      @events_to_publish.each do |event_name|
+        @event_sink.on_event(event_name) do |*args|
+          changed
+          notify_observers( event_name )
+        end
+        loop { WIN32OLE_EVENT.message_loop }
+      end
+    end
+    
+  end
+
+  # Generic Observer of BrowserEventsPublisher.
+  # implements update method of an observer to be notified by publisher of events
+  class BrowserEventsListener
+    attr_accessor :events
+    
+    def initialize( events_publisher )
+      events_publisher.add_observer self
+      @events = []
+    end
+
+    def update event_name
+      puts "#{Time.now}: #{event_name}"
+      @events << event_name
+    end
+  end
+end
+
+
+
+
+@ie = Watirloo.browser
+events = Thread.start do
+  @publisher = Watirloo::BrowserEventsPublisher.new(@ie)
+  @publisher.run
+end
+
+@listener = Watirloo::BrowserEventsListener.new(@publisher)
+
+puts "pub starter"
+puts @listener.events.inspect
+
+@ie.goto "http://yahoo.com/"
+puts @listener.events.inspect
+
+#sleep 60
+@ie.goto "http://yahoo.com/"
+puts @listener.events.inspect
+
+#at_exit do
+Thread.kill events
+#end
+
+#sleep 5