marekj-watirloo 0.0.3 → 0.0.5

data/lib/watirloo/locker.rb

@@ -0,0 +1,84 @@
+module Watirloo
+
+
+  # manages references to browsers we care about to run tests agains.
+  # Saves references to window handles internall to yaml file so we can reuse the browser for tests by reattaching to it between tests.
+  # you put reference to a browser in storage. Next time you run a test you can restore the browser's reference instead fo staring a new one.
+  module Locker
+
+    @@locker_file = File.join(File.dirname(__FILE__), "..", "..", "config", "locker.yml")
+
+    class << self
+
+      # hash of {key => IE.hwnd} to attach and reuse browsers
+      # example: mapping = {:default=> 234567, :bla => 234234}
+      def mapping
+        @mapping ||= read_mapping
+      end
+
+      def locker
+        @@locker_file
+      end
+
+      def locker=( locker )
+        @@locker_file = locker
+      end
+
+      # returns IE reference to a browser with a given key
+      def browser(key='default')
+        if key == 'default'
+          (@browser && @browser.exists?) ? @browser : @browser = attach_browser
+        else
+          attach_browser(key)
+        end
+      end
+
+      # add browser to storage for later reuse. by convention if you don't have any browsers it
+      # so you can later restore it and continue working with it.
+      # pass either browser referene or the hwnd Fixnum
+      def add(browser, key='default')
+        mapping[key] = browser.kind_of?(Watir::IE) ? browser.hwnd : browser
+        save_mapping
+      end
+
+      # remove browser from storage and from further reusing
+      def remove(key='default')
+        @browser = nil if key == 'default'
+        mapping.delete(key) if mapping[key]
+        save_mapping
+      end
+
+      # clear Storage
+      def clear
+        @browser = nil
+        mapping.clear
+        save_mapping
+      end
+
+      private
+
+      def read_mapping
+        if FileTest.exists?(locker)
+          loaded = YAML::load_file(locker)
+          #if file is empty or not well formed yaml
+          #or not a hash then return empty hash
+          loaded.kind_of?(Hash) ? loaded : {}
+        else
+          #empty hash if locker.yaml not there
+          #or malformed loaded not created yet
+          {} 
+        end
+      end
+
+      def save_mapping
+        File.open(locker,'w') {|f| YAML.dump(mapping, f)}
+      end
+
+      # throws exception if can't attach to the known handle. 
+      def attach_browser(key='default')
+        Watir::IE.attach(:hwnd, mapping[key])
+      end
+
+    end
+  end
+end

data/lib/watirloo/page.rb

@@ -0,0 +1,105 @@
+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
+
+    # provides access to the browser for a client
+    def browser
+      ::Watirloo.browser
+    end
+
+    # container that delimits the scope of elements.
+    # in a frameless DOM the browser is the doc
+    # however if page with frames you can setup a doc destination to be a frame as the
+    # base container for face accessors
+    def doc
+      browser
+    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) {doc.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.
+      #   face(:friendlyname) { watircode } where watircode is actuall way of accessing the element on the page.
+      # 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)   { doc.text_field(:name, 'q') }
+      #       face(:search)  { doc.button(:name, 'btnG') }
+      #     end
+      #
+      def face(name, *args, &definition)
+        module_eval do
+          define_method(name) do |*args|
+            instance_exec(*args, &definition)
+          end
+        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|
+        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(field_keys)
+      data = {}
+      field_keys.each do |k|
+        watir_control = send("#{k}")
+        method_name = case watir_control.class.to_s.split("::").last
+        when "SelectList", "CheckboxGroup", "RadioGroup" then :selected
+        else  
+          :value
+        end
+        data.update k => watir_control.send(method_name)
+      end
+      data
+    end
+
+
+  end
+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