marekj-watirloo 0.0.3 → 0.0.5

data/History.txt

@@ -1,3 +1,15 @@
+== 0.0.5 22Jul2009
+* Page is a module and not a class. include Watirloo::Page in your testcase (rspec group or cucumber feature) to add view methods.
+* Locker uses config/locker.yml by default. If you want your own somewhere in your project update the Watirloo::Locker.locker = "path/to/your/config/locker.yml"
+* multiple browser support with Watirloo::Desktop and Locker
+* 115 examples in rspec
+
+== 0.0.4 16feb2009
+* Radio and Checkbox Groups, UseCase class and reflector
+  * RadioGroups class and enhance radio_group(how, what) method
+  * CheckboxGroups class and enhance checkbox_group(how, what) method
+  * ElementCollections.reflect and Container.reflect method redesign
+  
 == 0.0.3 25jan2009
 
 * implement inheritable class interfaces

data/Manifest.txt

@@ -1,34 +1,59 @@
-History.txt
-Manifest.txt
-README.rdoc
-Rakefile.rb
-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/attach_instance_test.rb
-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/interfaces_test.rb
-test/label_test.rb
-test/person_def_wrappers_test.rb
-test/radio_group_test.rb
-test/select_list_in_class_test.rb
-test/select_list_options_test.rb
-test/select_lists_test.rb
-test/test_helper.rb
-test/text_fields_test.rb
-watirloo.gemspec
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile.rb
+config/locker.yml
+lib/watirloo.rb
+lib/watirloo/browsers.rb
+lib/watirloo/desktop.rb
+lib/watirloo/extension/firewatir_ducktape.rb
+lib/watirloo/extension/object.rb
+lib/watirloo/extension/watir_ducktape.rb
+lib/watirloo/extension/watir_reflector.rb
+lib/watirloo/locker.rb
+lib/watirloo/page.rb
+script/console
+script/console.cmd
+script/destroy
+script/destroy.cmd
+script/generate
+script/generate.cmd
+script/reflect.rb
+spec/browser_spec.rb
+spec/browser_threads_spec.rb
+spec/checkbox_group_spec.rb
+spec/checkbox_groups_spec.rb
+spec/checkboxes_value_spec.rb
+spec/desktop_spec.rb
+spec/extra/browser_events_spec.rb
+spec/extra/page_objects_metrics.rb
+spec/face_mixing_spec.rb
+spec/firewatir/attach_instance_test.rb
+spec/firewatir/spec_results.html
+spec/firewatir/spec_results.txt
+spec/firewatir/spec_results_failed.txt
+spec/html/census.html
+spec/html/checkbox_group1.html
+spec/html/labels.html
+spec/html/no_title.html
+spec/html/person.html
+spec/html/radio_group.html
+spec/html/select_lists.html
+spec/input_element_spec.rb
+spec/label_spec.rb
+spec/locker_spec.rb
+spec/page_spec.rb
+spec/person_def_wrappers_spec.rb
+spec/radio_group_spec.rb
+spec/radio_groups_spec.rb
+spec/reflector_spec.rb
+spec/select_list_options_spec.rb
+spec/select_lists_spec.rb
+spec/spec_helper.rb
+spec/spec_helper_ff.rb
+spec/spec_helper_runner.rb
+spec/spec_results.html
+spec/spec_results.txt
+spec/spec_results_failed.txt
+spec/text_fields_spec.rb
+watirloo.gemspec

data/README.rdoc

@@ -1,112 +1,95 @@
 = Watirloo
 
-* http://watirloo.testr.us
+* http://github.com/marekj/watirloo
 
 == 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
+Custom Extensions for Watir, Firewatir. Acceptance Test Helper based on semantic page objects modeling customer's domain language
+It helps you write human readable and machine executable browser tests. Isolates GUI from Tests.
 
-Give it a try. You will like it.
+The Human Readable part helps you create interfaces to elements on the page and tags them with friendly names 
+based on vocabulary of Business Domain. The Machine Executable parts talk to Watir API hooking into DOM elements. 
+it helps you concentrate in your acceptance tests on the intention and the customer's language and not on implementation of DOM.
+Write customer facing tests hence the metaphor of face for Page Objects of Significance to the Customer.
 
 == 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
+* Extensioins to Watir and Firewatir gems to ease testing
+* group radios in #radio_group and checkboxes in #checkbox_group and acts each group as page object
+* Maintains multiple browsers on the desktop and stores window handles so you can reattach to the browser under test later (see Watirloo::Locker)
+* Watches and maintains your desktop for browsers existence. (Watirloo::Desktop)
+* Browser is managed automatically with Watirloo::browser
+* Isolates GUI from tests with face methods that introduce customer facing friendly names for elements
+* add reflect method to generate scaffolding code for your page elements (reflect currently uses browser as container. Alter scaffodling if you use frames)
+* look at spec dir for examples of usage with rspec
+
 
 == SYNOPSIS:
 
-By convention Watirloo::Page.new attaches itself to the existing IE browser instance on the desktop.
+By convention Watirloo::browser attaches itself to the existing IE browser instance on the desktop and maintains the handles to reattach later
 
-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
+Example:
 
-  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"
+    Given a page with text fields for last name and first name
+    When I want to enter the name 'Kurt Vonnegut'
+    And I don't want to talk to implementation
+    But I want a friendly name of element on the page
+    Then I use Watirloo shortcuts
+    When I define an interface to watir implementation with a semantic key
+    And I define my data as hash with the same semantic key
+    Then I can automatically let watirloo enter my test data on a page
+
+    # rspec as container
+
+    describe "using watirloo page to isolate and bind gui view to data" do
+      include Watirloo::Page
+      face(:last) {browser.text_field(:name, 'l_nm')}
+      face(:first) {browser.text_field(:name, 'f_nm')}
+
+      it "enters data on the page" do
+        last.set "Vonnegut"
+        first.set "Kurt"
+      end
+
+      it "sprays data on elements defined" do
+        spray :last => 'Vonnegut', :first => 'Kurt'
+      end
+
+      it "grabs data from elements and validates" do
+        data = {:first => "Kurt", :last => 'Vonnegut'}
+        spray data
+        scrape(data.keys).should == data
+      end
 
-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
+* watir = 1.6.2 
+* firewatir = 1.6.2 if you want to use Firefox
+* newgem
+* rspec gem if you want to run watirloo examples included
 
 == INSTALL:
 
-* gem install watirloo
-
-=== ROADMAP
+* Run the following if you haven't already:
+    gem sources -a http://gems.github.com
 
-Towards version 0.0.3
+* Install the gem(s):
+  gem install marekj-watirloo
 
-* DONE: make class level interfaces as base for the class and subclass. remove it from initilize method
-* UseCase class, scenario based runner
-* clean up reflector method to reflect according to new interface structures
-* move RadioGroup and CheckboxGroup to Watir gem (work with Bret)
-* make RadioGroups and CheckboxGroups classes for both IE and Firefox
+* or download from : http://github.com/marekj/watirloo/downloads
 
-Towards version 0.0.2
+=== ROADMAP
 
-* DONE: make Watirloo agnostic to browser IE or Firefox or Safari
-* DONE: make tests run on IE, Firefox, Safari with the same interface
-* DONE: 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
+* add Logging gem and log all actions for audit
+* provide UserStory type of container for exploratory testing (UseCase, Feature, TestScenario etc...)
+* provide examples for Cucumber
+* make specs run with firewatir
 
 == 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.
-
+http://www.opensource.org/licenses/mit-license.php

data/Rakefile.rb

@@ -1,4 +1,4 @@
-%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+%w[rubygems rake rake/clean fileutils newgem rubigen spec].each { |f| require f }
 require File.dirname(__FILE__) + '/lib/watirloo'
 
 # Generate all the Rake tasks
@@ -12,10 +12,10 @@ $hoe = Hoe.new('watirloo', Watirloo::VERSION) do |p|
   ]
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"],
-    ['test/spec', '>=0.9.0']
+    ['rspec', ">= #{::Spec::VERSION::STRING}"]
   ]
-  p.test_globs  =['test/*_test.rb']
-  p.testlib = ['test/spec']
+  p.test_globs  =['spec/*_spec.rb']
+  p.testlib = ['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')
@@ -25,43 +25,36 @@ end
 require 'newgem/tasks' # load /tasks/*.rake
 Dir['tasks/**/*.rake'].each { |t| load t }
 
-desc "run all tests on IE."
-task :test_ie do
-  require 'rubygems' # needed?
-  gem 'ci_reporter'
-  require 'ci/reporter/rake/test_unit'
-  load 'ci/reporter/rake/test_unit_loader.rb'
 
-  # 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
-  chdir File.dirname(__FILE__) do
-    tests = Dir["test/*_test.rb"]
-    tests.each do |t|
-      require t
-    end
-  end
-
-  # at the end of test you will have one extra browser
+require 'spec/rake/spectask'
+desc "spec with ie browser"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.fail_on_error = false
+  t.spec_opts = [
+    #"--require spec/spec_helper_runner.rb", # slow execution expected
+    "--format specdoc",
+    "--format specdoc:spec/spec_results.txt",
+    "--format failing_examples:spec/spec_results_failed.txt",
+    "--format html:spec/spec_results.html",
+    #"--diff",
+    "--loadby mtime",
+    #"--dry-run", # will overwrite any previous spec_results
+    #"--generate-options spec/spec.opts",
+  ]
 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
+# FIXME fix the spec FileList to only include those that execut for firefox. use taglog lib
+desc "spec with ff browser"
+Spec::Rake::SpecTask.new(:spec_ff) do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.spec_opts = [
+    "--require spec/spec_helper_ff.rb",
+    "--format specdoc",
+    "--format specdoc:spec/firewatir/spec_results.txt",
+    "--format failing_examples:spec/firewatir/spec_results_failed.txt",
+    "--format html:spec/firewatir/spec_results.html",
+    "--loadby mtime" ]
 end
 
-
-
-
+#task :default => :spec

data/lib/watirloo.rb

@@ -1,169 +1,16 @@
 $:.unshift(File.dirname(__FILE__)) unless
 $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require 'watirloo/watir_ducktape'
-require 'watirloo/reflector'
+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.5' # Jul2009
 
-  VERSION = '0.0.3' # Jan2009
-  
-  # browser. we return IE or Firefox. Safari? Other Browser?
-  class BrowserHerd
-    
-    @@target = :ie
-    #targets = [:ie, :firefox]
-    
-    class << self
-      
-      def target=(indicator)
-        @@target = indicator
-      end
-    
-      def target
-        @@target
-      end
-    
-      # provides browser instance to client.
-      # attaches to the existing 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
-      # We are not doing any fancy 
-      # 
-      def 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
-        else
-          raise ::Watir::Exception::WatirException, "Browser target not supported"
-        end
-      end
-    end
-  end
-  
-  # Semantic Page Objects Container
-  # Page containes interfaces to Objects of Interest on the Web Page
-  # Each object defined by key, value pair, 
-  # Keys is a friendly name, recognizable name given by the domain object model.
-  # Some name that is meaningful to the customer.
-  # The value of the interface definiton is a Watir object address in the dom container.
-  # The Page class acts as an Adapter between the Business Domain naming of things and Document Object Model naming of elments.
-  # It strives to adapt Human Readable tests to Machine Executable code
-  class Page
-    
-    ## Page Eigenclass
-    class << self
-      
-      # hash key value pairs, 
-      # each interface definition is a key as symbol pointing to some code to
-      # exeucte later.
-      def interfaces
-        @interfaces ||= {} 
-      end
-      
-      # Declares Semantic Interface to the DOM elements on the Page 
-      #   face :friendlyname => [watirelement, how, what]
-      # Each interface or face is an object of interest that we want to access by its interface name
-      # example:
-      #   class GoogleSearch < Watirloo::Page
-      #     face :query => [:text_field, :name, 'q]
-      #     face :search => [:button, :name, 'btnG']
-      #  end
-      # each face is a key declared by a semantic symbol that has human meaning in the context of a usecase
-      # each value is an array defining access to Watir [:elementType, how, what]
-      def interface(definition)
-        if definition.kind_of? Hash
-          self.interfaces.update definition
-        else
-          raise ::Watir::Exception::WatirException, "Wrong arguments for Page Object definition"
-        end
-      end
-      alias face interface
-      
-      def inherited(subpage)
-        #puts "#{subpage} inherited #{interfaces.inspect} from #{self}"
-        subpage.interfaces.update self.interfaces #supply parent's interfaces to subclasses in eigenclass
-      end
-    end
-    
-    attr_accessor :b, :interfaces
-    
-    def browser
-      @b
-    end
-    
-    
-    def create_interfaces
-      @interfaces = self.class.interfaces.dup # do not pass reference, only values
-    end
-    
-    # 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.
-    # this provides simplicity for those who are just starting with Watirloo
-    def initialize(browser = Watirloo::BrowserHerd.browser , &blk)
-      @b = browser
-      create_interfaces
-      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 |facename, value|
-        get_face(facename).set value #make every element in the dom respond to set to set its value
-      end
-    end
-    
-    # set values on the page given the interface keys
-    alias set spray 
-  
-    # return Watir object given by its semantic face symbol name
-    def get_face(facename) 
-      if self.respond_to? facename # if there is a defined wrapper method for page element provided
-        return self.send(facename) 
-      elsif interfaces.member?(facename) # pull element from @interfaces and send to browser
-        method, *args = self.interfaces[facename] # return definition for face consumable by browser
-        return browser.send(method, *args) #returns Watir Element class
-      else
-        raise ::Watir::Exception::WatirException, 'Unknown Semantic Facename'
-      end
-    end
-    
-    # add face definition to page
-    def interface(definitions)
-      if definitions.kind_of?(Hash)
-        interfaces.update definitions
-      else
-        raise ::Watir::Exception::WatirException, "Wrong arguments for Page Object definition"
-      end
-    end
-    alias face interface
-    
-    # Delegate execution to browser if no method or face defined on page class
-    def method_missing method, *args
-      if browser.respond_to?(method.to_sym)
-        return browser.send(method.to_sym, *args)
-      elsif  interfaces.member?(method.to_sym)
-        return get_face(method.to_sym)
-      else
-        raise ::Watir::Exception::WatirException, 'I ran out of ideas in Watirloo'
-      end
-    end
-  end
+end
 
-end