marekj-watirloo 0.0.2 → 0.0.3

data/History.txt

@@ -1,10 +1,17 @@
-== 0.0.2 2009-02-03
+== 0.0.3 25jan2009
+
+* implement inheritable class interfaces
+  * subclasses inherit class level interfaces from superclasses
+  * initialize makes a set of interfaces to that instance only but inherits class interfaces from entire tree
+  * adding interfaces to the instance does not leak into classes
+
+== 0.0.2 03jan2009
 
 * 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
+== 0.0.1 22dec2008
 
 * initial merge with newgem generated structure to make it a gem
   * Patches to Watir and Firewatir

data/Manifest.txt

@@ -2,7 +2,6 @@ History.txt
 Manifest.txt
 README.rdoc
 Rakefile.rb
-lib/watirloo
 lib/watirloo.rb
 lib/watirloo/firewatir_ducktape.rb
 lib/watirloo/reflector.rb
@@ -16,19 +15,18 @@ 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/interfaces_test.rb
 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_in_class_test.rb
 test/select_list_options_test.rb
 test/select_lists_test.rb
 test/test_helper.rb

data/README.rdoc

@@ -70,11 +70,19 @@ Or pass page cofiguration in the block at page creation
 
 === ROADMAP
 
+Towards version 0.0.3
+
+* 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
+
 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
+* 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
 
 == LICENSE:

data/Rakefile.rb

@@ -8,8 +8,8 @@ $hoe = Hoe.new('watirloo', Watirloo::VERSION) do |p|
   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'],
-   ]
+    ['watir', '>= 1.6.2'],
+  ]
   p.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"],
     ['test/spec', '>=0.9.0']
@@ -18,7 +18,7 @@ $hoe = Hoe.new('watirloo', Watirloo::VERSION) do |p|
   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.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/, ''), 'rdoc')
   p.rsync_args = '-av --delete --ignore-errors'
 end
 
@@ -27,23 +27,31 @@ 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
-  tests = Dir["test/*_test.rb"]
-  tests.each do |t|
-    require t
+  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
 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
+  # 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"]

data/lib/watirloo.rb

@@ -1,57 +1,107 @@
 $:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.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
+  VERSION = '0.0.3' # 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
+  class BrowserHerd
     
-    @@target = :ie #default target
-
-    def self.target=(indicator)
-      @@target = indicator
-    end
+    @@target = :ie
+    #targets = [:ie, :firefox]
     
-    def self.target
-      @@target
-    end
+    class << self
+      
+      def target=(indicator)
+        @@target = indicator
+      end
+    
+      def 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
+      # 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 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
+  # 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
     
-    include TestObject
-    attr_accessor :b
-    attr_reader :faces
-
+    ## 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.
@@ -62,48 +112,54 @@ module Watirloo
     #   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
-      @faces = {}
-      instance_eval(&blk) if block_given? # allows the shortcut to do some work at page creation
+      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 |face_symbol, value|
-        get_face(face_symbol).set value #make every element in the dom respond to set to set its value
+      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(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)
+    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
-        #??? I ran out of ideas
-        raise ::Watir::Exception::WatirException, 'I ran out of ideas in Watirloo'
+        raise ::Watir::Exception::WatirException, 'Unknown Semantic Facename'
       end
     end
-    alias face get_face
-  
+    
     # add face definition to page
-    def add_face(definitions)
+    def interface(definitions)
       if definitions.kind_of?(Hash)
-        @faces.update definitions  
+        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 @b.respond_to? method
-        @b.send method, *args
-      elsif  @faces.member?(method.to_sym)
-        get_face(method.to_sym)
+      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

data/test/checkbox_group_test.rb

@@ -1,14 +1,29 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class CheckboxGroupPage < Watirloo::Page
-  # semantic wrapper for the radio group object
-  def pets
-    @b.checkbox_group('pets')
+describe 'checkbox_group access for browser' do
+  before :each do
+    page = Watirloo::Page.new
+    @browser = page.browser
+    @browser.goto testfile('checkbox_group1.html')
+  end
+  
+  it 'browser responds to checkbox_group' do
+    @browser.respond_to?(:checkbox_group).should == true
+  end
+  
+  it 'returns group object and its values from the page' do
+    cbg = @browser.checkbox_group('pets')
+    cbg.size.should == 5
+    cbg.values.should == %w[cat dog zook zebra wumpa]
   end
 end
 
+describe 'CheckboxGroup class access with page interface' do 
 
-describe 'CheckboxGroup class' do 
+  class CheckboxGroupPage < Watirloo::Page
+    # semantic wrapper for the radio group object
+    face :pets => [:checkbox_group, 'pets']
+  end
   
   before do
     @page = CheckboxGroupPage.new

data/test/checkboxes_value_test.rb

@@ -4,8 +4,13 @@ describe 'setting and getting values for individual checkboxes with value attrib
   
   before do
     @page = Watirloo::Page.new
-    @page.goto testfile('checkbox_group1.html')
-    @page.add_face(
+    @page.browser.goto testfile('checkbox_group1.html')
+    
+    # instance method page.face adds defintion but only to the current instance of the page
+    # in watir you have to access each checkbox. 
+    # in Watirloo you can access CheckboxGroup as shortcut using
+    # :pets => [:checkbox_group, 'pets']
+    @page.face(
       :pets_cat => [:checkbox, :name, 'pets', 'cat'],
       :pets_dog => [:checkbox, :name, 'pets', 'dog'],
       :pets_zook => [:checkbox, :name, 'pets', 'zook'],
@@ -15,32 +20,31 @@ describe 'setting and getting values for individual checkboxes with value attrib
   
   it 'semantic name accesses individual CheckBox' do
     if @page.b.kind_of?(FireWatir::Firefox)
-      @page.face(:pets_cat).kind_of?(FireWatir::CheckBox).should == true
+      @page.pets_cat.kind_of?(FireWatir::CheckBox).should == true
       
     elsif @page.b.kind_of?(Watir::IE)
-      @page.face(:pets_cat).kind_of?(Watir::CheckBox).should == true
+      @page.pets_cat.kind_of?(Watir::CheckBox).should == true
     end
   end
   
   it 'set individual checkbox does not set other checkboxes sharing the same name' do
-    @page.face(:pets_dog).checked?.should == false
-    @page.face(:pets_dog).set
-    @page.face(:pets_dog).checked?.should == true
-    @page.face(:pets_cat).checked?.should == false
+    @page.pets_dog.checked?.should == false
+    @page.pets_dog.set
+    @page.pets_dog.checked?.should == true
+    @page.pets_cat.checked?.should == false
   end
   
   it 'by default all are false. set each unchecked checkbox should have checked? true' do
-    @page.faces.keys.each do |key|
-      @page.face(key).checked?.should == false
+    @page.interfaces.keys.each do |key|
+      @page.get_face(key).checked?.should == false
     end
 
-    @page.faces.keys.each do |key|
-      @page.face(key).set
+    @page.interfaces.keys.each do |key|
+      @page.get_face(key).set
     end
     
-    @page.faces.keys.each do |key|
-      @page.face(key).checked?.should.be true    
+    @page.interfaces.keys.each do |key|
+      @page.get_face(key).checked?.should.be true
     end
   end
-  
 end

data/test/html/checkbox_group1.html

@@ -1,7 +1,7 @@
 <!-- 
     Document   : checbox_group
 -->
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCtype HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
   <head>
     <title></title>
@@ -9,12 +9,12 @@
   </head>
   <body>
     <h3>Pets CheckboxGroup. Each has value. Acts like MultiSelectList. none, one ore more items can be checked.</h3>
-    <INPUT NAME="pets" TYPE="CHECKBOX" VALUE="cat">cat<br />
-    <INPUT NAME="pets" TYPE="CHECKBOX" VALUE="dog">dog<br />
-    <INPUT NAME="pets" TYPE="CHECKBOX" VALUE="zook">zook<br />
-    <INPUT NAME="pets" TYPE="CHECKBOX" VALUE="zebra">zebra<br />
-    <INPUT NAME="pets" TYPE="CHECKBOX" VALUE="wumpa">wumpa<br />
+    <input name="pets" type="checkbox" value="cat">cat<br />
+    <input name="pets" type="checkbox" value="dog">dog<br />
+    <input name="pets" type="checkbox" value="zook">zook<br />
+    <input name="pets" type="checkbox" value="zebra">zebra<br />
+    <input name="pets" type="checkbox" value="wumpa">wumpa<br />
     <h3>Single CheckboxToggle Only. Acts like RadioGroup on/off switch.</h3>
-    <INPUT NAME="singleIndicator" TYPE="checkbox">ToggleMe<br /> 
+    <input name="singleIndicator" type="checkbox">ToggleMe<br /> 
   </body>
 </html>

data/test/interfaces_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+describe "SuperPage" do
+
+  class SuperPage < Watirloo::Page
+    face 'name' => 'vname'
+  end
+  
+  it 'class interface' do
+    SuperPage.interfaces.keys.should == ['name']
+  end
+  
+  it 'instance initialized from class interface' do
+    SuperPage.new.interfaces.keys.should == ['name']
+  end
+  
+  it 'adding interface to instance adds interface to initialize' do
+    page = SuperPage.new
+    page.face 'sub' => 'sub' # add new face to instance
+    page.interfaces.keys.sort.should == %w[name sub] # instnace has now two
+  end
+  
+  it 'but not to class' do
+    page = SuperPage.new
+    page.face 'sub' => 'sub'
+    page.interfaces.keys.sort.should == %w[name sub]
+    SuperPage.interfaces.keys.should == ['name'] # but the class has still only one
+  end
+  
+  it 'class interface can be updated' do
+    SuperPage.interfaces.update 'update' => 'vupdate'
+    SuperPage.interfaces.keys.sort.should == %w[name update]
+  end
+  
+  it 'instance gets interfaces from class but does not get them after updating class' do
+    page = SuperPage.new
+    page.interfaces.keys.sort.should == %w[name update] #previous example altered it
+    SuperPage.interfaces.update 'muddy' => 'vmuddy'
+    page.interfaces.keys.sort.should == %w[name update] #previous example altered it
+  end
+end
+
+describe "SuperPage and SubPage" do
+  
+  class Page0 < Watirloo::Page
+    face 'higher' => 'vhigher'
+  end
+  class Page1 < Page0
+    face 'lower' => 'vlower'
+  end
+  class Page2 < Page1
+    face 'lowest' => 'vlowest'
+  end
+  
+  it 'Subpage inherits from Super its interfaces' do
+    p1 = Page1.new
+    p1.interfaces.keys.sort.should == %w[higher lower]
+  end
+  
+  it "Super retains its interfaces and is not affected by Subpages" do
+    p0 = Page0.new
+    p0.face 'supinst' => 'vsupinst'
+    p0.interfaces.keys.sort.should == %w[higher supinst]
+    Page0.interfaces.keys.sort.should == ['higher']
+    
+    p1 = Page1.new
+    p1.face 'subinst' => 'vsubinst'
+    p1.interfaces.keys.sort.should == %w[higher lower subinst]
+    Page1.interfaces.keys.sort.should == %w[higher lower]
+    
+    # extra checks
+    p0.interfaces.keys.sort.should == %w[higher supinst] #super not affected by Sub
+    Page0.interfaces.keys.sort.should == ['higher'] #not affected by P1.instance face
+    Page2.interfaces.keys.sort.should == %w[higher lower lowest]
+  end
+  
+  
+end

data/test/label_test.rb

@@ -3,8 +3,8 @@ describe 'label wrapping text field' do
   
   before do
     @page = Watirloo::Page.new
-    @page.goto testfile('labels.html')
-    @page.add_face(
+    @page.browser.goto testfile('labels.html')
+    @page.face(
       :first => [:text_field, :name, 'fn'],
       :last => [:text_field, :name, 'ln']
     )
@@ -47,7 +47,7 @@ describe 'label for text field' do
   before do
     @page = Watirloo::Page.new
     @page.goto testfile('labels.html')
-    @page.add_face(
+    @page.face(
       :first => [:text_field, :id, 'first_nm'],
       :last => [:text_field, :id, 'last_nm'],
       :first_label => [:label, :for, 'first_nm'],

data/test/person_def_wrappers_test.rb

@@ -1,50 +1,51 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-# def wrappers with suggested semantic names for elements
+# There are 3 ways of defining an interface
+# 1. class level face hash definition
+# 2 def semanticname wrapper created for element
+# 3 or just delegate to the browsing with familiar watir api
 class Person < Watirloo::Page
-  
+
+  # class level interfaces as definitions for Browser
+  face :first => [:text_field, :name, 'first_nm']
+  face :street => [:text_field, :name, 'addr1']
+
+  # def wrapper with suggested semantic name returns dom element
+  # these wrappers can provide specialized behavior on the page
   def last
     @b.text_field(:name, 'last_nm')
   end
 
-  def first
-    @b.text_field(:name, 'first_nm')
-  end
-
   def dob
     @b.text_field(:name, 'dob')
   end
 
-  def street
-    @b.text_field(:name, 'addr1')
-  end
-  
-  def gender
-    @b.select_list(:name, 'sex_cd')
-  end
-  
 end
 
 
-describe "Person Page with def wrapper methods" do
+describe "Person Page interfaces defined by def wrappers and class definitions" do
   
   before :each do
     @page = Person.new
-    @page.b.goto testfile('person.html')
+    @page.browser.goto testfile('person.html')
   end
   
   it 'calling face when there is wrapper method' do
-    
     @page.last.set 'Wonkatonka'
     @page.last.value.should == 'Wonkatonka'
-    @page.face(:last).value.should == 'Wonkatonka'
-    
-    @page.face(:last).set 'Oompaloompa'
-    @page.last.value.should == 'Oompaloompa'
-    
   end
   
-  it 'spray using methods wrappers for watir elements' do
+  it 'calling interface when there is definition and no method' do
+    @page.first.set 'Oompaloompa'
+    @page.first.value.should == 'Oompaloompa'
+  end
+  
+  it 'delegating to browser when there is no definition' do
+    @page.select_list(:name, 'sex_cd').set 'F'
+    @page.select_list(:name, 'sex_cd').selected.should == 'F'
+  end
+  
+  it 'spray method by convetion has keys correspondig to interface names for watir elements' do
     mapping = {:street => '13 Sad Enchiladas Lane', :dob => '02/03/1977'}
     @page.spray mapping
     @page.street.value.should == mapping[:street]
@@ -52,5 +53,3 @@ describe "Person Page with def wrapper methods" do
   end
   
 end
-
-

data/test/radio_group_test.rb

@@ -1,17 +1,32 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class RadioGroupPage < Watirloo::Page
-  # RadioGroup Class refers to collection of radios sharing the same name
-  def meals_to_go
-    @b.radio_group('food')
+describe 'RadioGroup class access in watir browser' do
+  before :each do
+    @browser = Watirloo::Page.new.browser
+    @browser.goto testfile('radio_group.html')
+  end
+  
+  it 'browser responds to radio_group' do
+    @browser.respond_to?(:radio_group).should == true
+  end
+  
+  it 'finds radio group on the page' do
+    rg = @browser.radio_group('food')
+    rg.size.should == 3
+    rg.values.should == %w[hotdog burger tofu]
   end
 end
 
-describe 'RadioGroup class' do
+
+describe 'RadioGroup class interface in watirloo' do
+  
+  class RadioGroupPage < Watirloo::Page
+    face :meals_to_go => [:radio_group, 'food']
+  end
 
   before do
     @page = RadioGroupPage.new
-    @page.b.goto testfile('radio_group.html')
+    @page.browser.goto testfile('radio_group.html')
   end
   
   it 'container radio_group method returns RadioGroup class' do
@@ -78,5 +93,5 @@ describe 'RadioGroup class' do
       @page.meals_to_go.set :yes
     end
   end
-  
+
 end

data/test/select_list_in_class_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+describe "select lists defining in class, instance and subclass" do
+  
+  class SelectListPage < Watirloo::Page
+    face :pets => [:select_list, :name, 'animals']
+  end
+  
+  before do
+    @page = SelectListPage.new
+    @page.face :gender => [:select_list, :name, 'sex_cd']
+    @page.browser.goto testfile('select_lists.html')
+  end
+  
+  it 'face method with key parameter to construct SelectList per browser implementation' do
+    if @page.browser.kind_of?(FireWatir::Firefox)
+      @page.pets.kind_of?(FireWatir::SelectList).should == true
+      @page.gender.kind_of?(FireWatir::SelectList).should == true
+      
+    elsif @page.browser.kind_of? Watir::IE
+      @page.pets.kind_of?(Watir::SelectList).should == true
+      @page.gender.kind_of?(Watir::SelectList).should == true
+    end
+  end
+  
+  it 'face(:facename) and browser.select_list access the same control' do
+    @page.select_list(:name, 'sex_cd').values.should == @page.gender.values
+    @page.select_list(:name, 'animals').values.should == @page.pets.values
+  end
+  
+  it 'subclassing the page and adding new interface gets previous ' do
+    class SelectListSub < SelectListPage
+      face :toys => [:select_list, :name, 'bubel']
+    end
+    page = SelectListSub.new
+    page.interfaces.keys.should == [:toys, :pets]
+  end
+
+end

data/test/select_list_options_test.rb

@@ -5,17 +5,12 @@ describe "SelectList options as visible items and values as hidden to the user a
   before do
     @page = Watirloo::Page.new
     @page.b.goto testfile('select_lists.html')
-    @page.add_face(
+    @page.face(
       :pets => [:select_list, :name, 'animals'],
       :gender => [:select_list, :name, 'sex_cd'],
       :toys => [:select_list, :name, 'bubel'])
   end
   
-  it 'values of options by face(:facename) method' do
-    @page.face(:gender).values.should == ['', 'm', 'f']
-    @page.face(:pets).values.should == ['o1', 'o2', 'o3', 'o4', 'o5']
-  end
-  
   it 'values of options by facename method' do
     @page.gender.values.should == ['', 'm', 'f']
     @page.pets.values.should == ['o1', 'o2', 'o3', 'o4', 'o5']
@@ -31,11 +26,11 @@ describe "SelectList options as visible items and values as hidden to the user a
     end
   end
   
-  it 'options method returns visible contents as array of text items' do
+  it 'items method returns visible contents as array of text items' do
     @page.toys.items.should == ["", "foobel", "barbel", "bazbel", "chuchu"]
   end
   
-  it 'options returns visible text items as array' do
+  it 'items returns visible text items as array' do
     @page.pets.items.should == ['cat', 'dog', 'zook', 'zebra', 'wumpa']
     @page.gender.items.should == ["", "M", "F"]
   end

data/test/select_lists_test.rb

@@ -6,7 +6,7 @@ describe "SelectList selections" do
   before do
     @page = Watirloo::Page.new
     @page.b.goto testfile('select_lists.html')
-    @page.add_face(
+    @page.face(
       :pets => [:select_list, :name, 'animals'],
       :gender => [:select_list, :name, 'sex_cd'])
   end

data/test/text_fields_test.rb

@@ -7,23 +7,23 @@ describe "add faces text fields page objects" do
     @page.b.goto testfile('person.html')
   end
 
-  it 'faces initially is an empty Hash' do
-    @page.faces.should == {}
+  it 'interfaces initially is an empty Hash' do
+    @page.interfaces.should == {}
   end
   
-  it 'add_face accepts keys as semantic faces and values as definitions to construct Watir Elements' do
-    @page.add_face(
+  it 'instance method face accepts keys as semantic faces and values as definitions to construct Watir Elements' do
+    @page.face(
       :last => [:text_field, :name, 'last_nm'],
       :first => [:text_field, :name, 'first_nm'])
-    @page.faces.size.should == 2
-    #TODO TextField should be Watir and independent of Browser IE, FireFox or others.
-    if @page.b.kind_of? FireWatir::Firefox
-      @page.face(:first).kind_of?(FireWatir::TextField).should == true
-      @page.face(:last).kind_of?(FireWatir::TextField).should == true
+    @page.interfaces.size.should == 2
+    
+    if @page.browser.kind_of? FireWatir::Firefox
+      @page.first.kind_of?(FireWatir::TextField).should == true
+      @page.last.kind_of?(FireWatir::TextField).should == true
       
     elsif @page.b.kind_of? Watir::IE
-      @page.face(:first).kind_of?(Watir::TextField).should == true
-      @page.face(:last).kind_of?(Watir::TextField).should == true
+      @page.first.kind_of?(Watir::TextField).should == true
+      @page.last.kind_of?(Watir::TextField).should == true
     end
   end
 end
@@ -33,30 +33,17 @@ describe "text fields page objects setting and getting values" do
   before do
     @page = Watirloo::Page.new
     @page.goto testfile('person.html')
-    @page.add_face(
+    @page.face(
       :last => [:text_field, :name, 'last_nm'],
       :first => [:text_field, :name, 'first_nm']
     )
   end
-
-  it "face name keyword and value returns current text" do
-    @page.face(:first).value.should == 'Joanney'
-    @page.face(:last).value.should == 'Begoodnuffski'
-  end
   
   it 'face name method and value returns current text' do
     @page.first.value.should == 'Joanney'
     @page.last.value.should == 'Begoodnuffski'    
   end
   
-  it "face name kewords and set enters value into field" do
-    params = {:first => 'Grzegorz',:last => 'Brzeczyszczykiewicz'}
-    @page.face(:first).set params[:first]
-    @page.face(:last).set params[:last]
-    @page.face(:first).value.should == params[:first]
-    @page.face(:last).value.should == params[:last]  
-  end
-  
   it "face name method and set enters value into field" do
     params = {:first => 'Grzegorz',:last => 'Brzeczyszczykiewicz'}
     @page.first.set params[:first]
@@ -65,10 +52,17 @@ describe "text fields page objects setting and getting values" do
     @page.last.value.should == params[:last]  
   end
   
+  it 'spray method matches keys to semantic values and sets values' do
+    params = {:first => 'Grzegorz',:last => 'Brzeczyszczykiewicz'}
+    @page.spray params
+    @page.first.value.should == params[:first]
+    @page.last.value.should == params[:last]  
+    
+  end
   it 'spray values match semantic keys to faces and set their values' do
     @page.spray :first => 'Hermenegilda', :last => 'Kociubinska'
-    @page.face(:first).value.should == 'Hermenegilda'
-    @page.face(:last).value.should == 'Kociubinska'
+    @page.first.value.should == 'Hermenegilda'
+    @page.last.value.should == 'Kociubinska'
   end
 end
  

data/watirloo.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{watirloo}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["marekj"]
-  s.date = %q{2009-01-07}
+  s.date = %q{2009-01-25}
   s.description = %q{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.}
   s.email = ["marekj.com@gmail.com"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
-  s.files = ["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"]
+  s.files = ["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"]
   s.has_rdoc = true
   s.homepage = %q{http://watirloo.testr.us}
   s.rdoc_options = ["--main", "README.rdoc"]
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{watirloo}
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{Watir Framework and Helper based on Semantic Page Objects Modeling}
-  s.test_files = ["test/checkboxes_value_test.rb", "test/checkbox_group_test.rb", "test/label_test.rb", "test/person_def_wrappers_test.rb", "test/radio_group_test.rb", "test/select_lists_test.rb", "test/select_list_as_face_test.rb", "test/select_list_options_test.rb", "test/text_fields_test.rb"]
+  s.test_files = ["test/checkboxes_value_test.rb", "test/checkbox_group_test.rb", "test/interfaces_test.rb", "test/label_test.rb", "test/person_def_wrappers_test.rb", "test/radio_group_test.rb", "test/select_lists_test.rb", "test/select_list_in_class_test.rb", "test/select_list_options_test.rb", "test/text_fields_test.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: marekj-watirloo
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - marekj
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-07 00:00:00 -08:00
+date: 2009-01-25 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,7 +64,6 @@ files:
 - Manifest.txt
 - README.rdoc
 - Rakefile.rb
-- lib/watirloo
 - lib/watirloo.rb
 - lib/watirloo/firewatir_ducktape.rb
 - lib/watirloo/reflector.rb
@@ -78,19 +77,18 @@ files:
 - 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/interfaces_test.rb
 - 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_in_class_test.rb
 - test/select_list_options_test.rb
 - test/select_lists_test.rb
 - test/test_helper.rb
@@ -126,10 +124,11 @@ summary: Watir Framework and Helper based on Semantic Page Objects Modeling
 test_files: 
 - test/checkboxes_value_test.rb
 - test/checkbox_group_test.rb
+- test/interfaces_test.rb
 - test/label_test.rb
 - test/person_def_wrappers_test.rb
 - test/radio_group_test.rb
 - test/select_lists_test.rb
-- test/select_list_as_face_test.rb
+- test/select_list_in_class_test.rb
 - test/select_list_options_test.rb
 - test/text_fields_test.rb

data/test/select_list_as_face_test.rb

@@ -1,46 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-describe "select list as semantic face object on a page" do
-  
-  before do
-    @page = Watirloo::Page.new
-    @page.b.goto testfile('select_lists.html')
-    @page.add_face(
-      :pets => [:select_list, :name, 'animals'],
-      :gender => [:select_list, :name, 'sex_cd'])
-  end
-  
-  it 'face method with key parameter to construct SelectList per browser implementation' do
-    if @page.b.kind_of?(FireWatir::Firefox)
-      @page.face(:pets).kind_of?(FireWatir::SelectList).should == true
-      @page.face(:gender).kind_of?(FireWatir::SelectList).should == true
-      
-    elsif @page.b.kind_of? Watir::IE
-      @page.face(:pets).kind_of?(Watir::SelectList).should == true
-      @page.face(:gender).kind_of?(Watir::SelectList).should == true
-    end
-  end
-  
-  it 'face(:facename) and browser.select_list access the same control' do
-    @page.b.select_list(:name, 'sex_cd').values.should == @page.gender.values
-    @page.b.select_list(:name, 'animals').values.should == @page.pets.values
-  end
-  
-  
-  it 'face(:facename) and facename access the same control' do
-    @page.face(:gender).items.should == @page.gender.items
-    @page.face(:pets).items.should == @page.pets.items
-  end
-
-  it 'facename method matching modeling semantic object accessor' do
-    if @page.b.kind_of?(FireWatir::Firefox)
-      @page.pets.kind_of?(FireWatir::SelectList).should == true
-      @page.gender.kind_of?(FireWatir::SelectList).should == true
-      
-    elsif @page.b.kind_of?(Watir::IE)
-      @page.pets.kind_of?(Watir::SelectList).should == true
-      @page.gender.kind_of?(Watir::SelectList).should == true
-    end
-    
-  end
-end