selenium-webdriver-viewers 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michael Collas
+
+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.

data/README.rdoc

@@ -0,0 +1,17 @@
+= selenium-webdriver-viewers
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Michael Collas. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "selenium-webdriver-viewers"
+    gem.summary = 'Makes page objects and views for tests using selenium-webdriver.'
+    gem.description = <<-END_DESCRIPTION
+      This gem makes it easy to create page and web viewer objects for use by tests that use selenium-webdriver. By
+      using page and viewer objects, you can decouple your tests from the html details so that they can focus
+      instead on describing the behaviour of your application. 
+    END_DESCRIPTION
+    gem.email = "mcollas@yahoo.com"
+    gem.homepage = "http://github.com/michaelcollas/selenium-webdriver-viewers"
+    gem.authors = ["Michael Collas"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "reek", ">= 1.2.8"
+    gem.add_development_dependency "sexp_processor", ">= 3.0.4"
+    gem.files.exclude('.gitignore')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'reek/rake/task'
+  Reek::Rake::Task.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+    t.reek_opts << ' --quiet'
+    t.ruby_opts << '-r' << 'rubygems' 
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "selenium-webdriver-viewers #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1,14 @@
+This project
+============
+licence
+attributes with different read/write types
+samples
+documentation
+
+Related projects
+================
+rspec-rails integration
+cucumber integration
+interaction objects
+state objects
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/browser-instance.rb

@@ -0,0 +1,61 @@
+require 'selenium-webdriver'
+require 'selenium/webdriver/navigation'
+
+module BrowserInstance
+
+  class << self
+    
+    def base_url=(new_value)
+      @base_url = new_value
+      @browser.navigate.base_url = @base_url if @browser
+    end
+    
+    def base_url
+      @base_url || ENV['BASE_URL'] || ''
+    end
+
+    def browser_instance
+      @browser ||= create_browser
+    end
+  
+    def create_browser
+      browser = Selenium::WebDriver.for :firefox
+      browser.navigate.extend(BaseUrl).base_url = base_url
+      browser
+    end
+    
+    def quit
+      return unless @browser
+      @browser.quit
+      @browser = nil
+    end
+    
+  end
+
+  def browser
+    BrowserInstance.browser_instance
+  end
+
+end
+
+module BaseUrl
+  
+  def self.extended(target)
+    super
+    class << target
+      alias_method :to_absolute, :to
+      alias_method :to, :to_relative
+    end
+  end
+
+  def to_relative(new_location)
+    to_absolute(@base_url + new_location)
+  end
+  
+  def base_url=(base)
+    @base_url = base
+  end
+  
+end
+
+

data/lib/element_reader.rb

@@ -0,0 +1,43 @@
+module WebViewer
+
+  # ElementReader fetches a Selenium::WebDriver::Element for a particular selector. If the selector
+  # requires parameters, ElementReader defers reading from WebDriver until the parameters are
+  # provided using the [] method.
+  class ElementReader
+
+    def initialize(viewer, selector, selector_type)
+      @viewer = viewer
+      @selector = selector
+      @selector_type = selector_type
+    end
+ 
+    def requires_parameters?
+      @selector.respond_to?(:call) && @selector.respond_to?(:arity) && @selector.arity > 0
+    end
+
+    def callable_selector?
+      @selector.respond_to?(:call) 
+    end
+
+    # return either self or element depending on whether selector needs parameters
+    def get(*arguments)
+      return element unless callable_selector?
+      if (arguments.length > 0) || !requires_parameters?
+        element(@selector.call(*arguments))
+      else
+        self
+      end
+    end
+
+    def [](*arguments)
+      selector_text = @selector.call(*arguments)
+      self.element(selector_text)
+    end
+
+    def element(selector_text = @selector)
+      @viewer.find_element(@selector_type, selector_text)
+    end
+
+  end
+
+end

data/lib/element_value_reader.rb

@@ -0,0 +1,50 @@
+module WebViewer
+
+  # ElementValueReader acts on a Selenium::WebDriver::Element by fetching its value, clicking on it,
+  # reading its text, etc. 
+  class ElementValueReader
+
+    def initialize(element_reader, output_type)
+      @element_reader = element_reader
+      @output_type = output_type
+    end
+
+    # return either self or element_value depending on whether selector needs parameters
+    def get
+      if @element_reader.requires_parameters?
+        self
+      else
+        element_value
+      end
+    end
+
+    def [](*args)
+      element_value(*args)
+    end
+
+    def []=(*arguments)
+      value_to_assign = arguments.pop
+      element = @element_reader.get(*arguments)
+      ElementValueWriter.new(element, @output_type).value = value_to_assign
+    end
+
+    def element_value(*arguments)
+      if (Class === @output_type)
+        element_as_viewer(*arguments)
+      elsif [:auto, :link, :select_by_text, :select_by_value].include? @output_type
+        raise "not yet implemented"
+      else
+        @element_reader.get(*arguments).send(@output_type)
+      end
+    end
+
+    def element_as_viewer(*arguments)
+      viewer = @output_type.new
+      base_element_proc = lambda { @element_reader.get(*arguments) }
+      viewer.instance_variable_set(:@base_element_proc, base_element_proc)
+      viewer
+    end
+
+  end
+
+end

data/lib/element_value_writer.rb

@@ -0,0 +1,19 @@
+module WebViewer
+
+  # ElementValueWriter assigns a value to a Selenium::WebDriver::Element. It uses the element_type
+  # parameter passed in the constructor to determine how to write to the element.
+  class ElementValueWriter
+
+    def initialize(web_element, element_type)
+      @web_element = web_element
+      @element_type = element_type
+    end
+
+    def value=(new_value)
+      # do smart things with element_type in here
+      @web_element.value = new_value
+    end
+
+  end
+
+end

data/lib/page.rb

@@ -0,0 +1,45 @@
+require 'browser-instance'
+require 'viewer'
+
+module WebPage
+  
+  def self.included(target)
+    super
+    target.extend ClassMethods
+  end
+  
+  def load
+    if respond_to?(:url) 
+      navigate.to_absolute(url) 
+    elsif respond_to?(:path)
+      navigate.to_relative(path) 
+    end
+    self
+  end
+  
+  module ClassMethods
+    
+    def url(url_value)
+      define_method(:url) { url_value }
+    end
+    
+    def path(path_value)
+      define_method(:path) { path_value }
+    end
+    
+    def load
+      new.load
+    end
+    
+  end
+  
+end
+
+# WebPageObject is a base class for web viewers that represent a whole page. In addition to 
+# all the normal features of a web viewer, a web page object has url or path, and can 
+# navigate to the url or path using the load method.
+class WebPageObject
+  include BrowserInstance
+  include WebViewer
+  include WebPage
+end

data/lib/selenium-webdriver-viewers.rb

@@ -0,0 +1,2 @@
+require 'viewer'
+require 'page'

data/lib/viewer.rb

@@ -0,0 +1,96 @@
+require 'forwardable'
+require 'browser-instance'
+require 'webdriver-extensions'
+require 'element_reader'
+require 'element_value_reader'
+require 'element_value_writer'
+
+module WebViewer
+  
+  extend Forwardable
+  def_delegators :browser, :close, :current_url, :execute_script, :get, :manage, :navigate, :page_source, 
+                           :save_screenshot, :screenshot_as, :script, :switch_to, :title, :visible=, :visible?, 
+                           :window_handle, :window_handles  
+  def_delegators :base_element, :[], :all, :attribute, :clear, :click, :displayed?, :drag_and_drop_by, :drag_and_drop_on, 
+                                :enabled?, :find_element, :find_elements, :first, :hover, :location, :ref, :select, :selected?, 
+                                :send_key, :send_keys, :size, :style, :submit, :tag_name, :text, :toggle, :value, 
+                                :element_present?, :wait_for_element_present
+            
+
+  def self.included(target)
+    super
+    target.extend ClassMethods
+  end
+  
+  def base_element
+    return @base_element_proc.call if @base_element_proc
+    browser.find_element(:tag_name, 'html')
+  end
+
+  def showing?
+    base_element
+    true
+    rescue Selenium::WebDriver::Error::NoSuchElementError
+      false
+  end
+
+  module ClassMethods
+    
+    def base_element(selector, selector_type=:id)
+      define_method(:base_element) do
+        browser.find_element selector_type, selector
+      end
+    end
+
+    def default_selector_type(selector_type)
+      @default_selector_type = selector_type
+    end
+
+    # :as options: :auto, :text, :click, :link, :select_by_text, :select_by_value, :hover, :location, :size, :toggle, :value, ViewerClass
+    def element(name, selector=name.to_s, options={}, &selector_proc)
+      if options.empty? && selector.is_a?(::Hash)
+        options = selector
+        selector = name
+      end
+      selector = selector_proc if selector_proc
+      selector_type = options[:by] || @default_selector_type || :id
+      output_type = options[:as] || :value
+
+      define_method("#{name}_element_reader") do
+        ElementReader.new(self, selector, selector_type)
+      end
+
+      define_method("#{name}_element") do 
+        send("#{name}_element_reader").get
+      end
+
+      define_method(name) do 
+        element_reader = send("#{name}_element_reader")
+        ElementValueReader.new(element_reader, output_type).get
+      end
+
+      # only define this method if result type suggests assignability
+      define_method("#{name}=") do |new_value|
+        element_reader = send("#{name}_element_reader")
+        raise "parameters required" if element_reader.requires_parameters?
+        ElementValueWriter.new(element_reader.get, output_type).value = new_value
+      end
+
+      define_method("#{name}_present?") do |*arguments|
+        raise ArgumentError(1, arguments.length) if arguments.length > 1
+        timeout = arguments[0].to_f
+        element_present? selector_type, selector, timeout
+      end
+      alias_method "has_#{name}?", "#{name}_present?"
+
+    end
+
+  end
+
+end
+
+class WebViewerObject
+  include BrowserInstance
+  include WebViewer
+end
+

data/lib/webdriver-extensions.rb

@@ -0,0 +1,53 @@
+require 'selenium-webdriver'
+
+module HumaneWebDriverExtensions
+  # deal with different html element types:
+  #    boolean for checkboxes, radio buttons, and individual options in select controls
+  #    string for inputs, textarea, and selects
+  #    send JavaScript for hidden inputs?
+  def value=(new_value)
+    case self.tag_name.to_sym
+      when :input, :textarea
+        clear
+        send_keys new_value.to_s
+      else
+        raise "cannot set value for a #{self.tag_name} element - only input and textarea supported"
+    end
+  end
+end
+
+module Selenium
+  module WebDriver
+
+    module Find
+      
+      def element_present?(how, what, how_long=0)
+        wait_for_element_present(how, what, how_long)
+        true
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+          false
+      end
+      
+      def wait_for_element_present(how, what, how_long)
+        attempts_left = how_long / 0.1
+        begin
+          find_element(how, what)
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+          if attempts_left > 0
+            attempts_left -= 1
+            sleep 0.1
+            retry
+          end
+          fail
+        end
+      end
+      
+    end
+
+    class Element
+      include HumaneWebDriverExtensions
+    end
+ 
+  end
+end
+

data/selenium-webdriver-viewers.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{selenium-webdriver-viewers}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Collas"]
+  s.date = %q{2010-12-16}
+  s.description = %q{      This gem makes it easy to create page and web viewer objects for use by tests that use selenium-webdriver. By
+      using page and viewer objects, you can decouple your tests from the html details so that they can focus
+      instead on describing the behaviour of your application. 
+}
+  s.email = %q{mcollas@yahoo.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc",
+    "TODO"
+  ]
+  s.files = [
+    ".document",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "TODO",
+    "VERSION",
+    "lib/browser-instance.rb",
+    "lib/element_reader.rb",
+    "lib/element_value_reader.rb",
+    "lib/element_value_writer.rb",
+    "lib/page.rb",
+    "lib/selenium-webdriver-viewers.rb",
+    "lib/viewer.rb",
+    "lib/webdriver-extensions.rb",
+    "selenium-webdriver-viewers.gemspec",
+    "spec/browser-instance_spec.rb",
+    "spec/element_reader_spec.rb",
+    "spec/element_value_reader_spec.rb",
+    "spec/element_value_writer_spec.rb",
+    "spec/page_spec.rb",
+    "spec/selenium-webdriver-viewers_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb",
+    "spec/viewer_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/michaelcollas/selenium-webdriver-viewers}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Makes page objects and views for tests using selenium-webdriver.}
+  s.test_files = [
+    "spec/browser-instance_spec.rb",
+    "spec/element_reader_spec.rb",
+    "spec/element_value_reader_spec.rb",
+    "spec/element_value_writer_spec.rb",
+    "spec/page_spec.rb",
+    "spec/selenium-webdriver-viewers_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/viewer_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<reek>, [">= 1.2.8"])
+      s.add_development_dependency(%q<sexp_processor>, [">= 3.0.4"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<reek>, [">= 1.2.8"])
+      s.add_dependency(%q<sexp_processor>, [">= 3.0.4"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<reek>, [">= 1.2.8"])
+    s.add_dependency(%q<sexp_processor>, [">= 3.0.4"])
+  end
+end
+

data/spec/browser-instance_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe BrowserInstance do
+
+  describe '#base_url' do
+
+    before do
+      BrowserInstance.base_url = nil
+    end
+
+    after do
+      BrowserInstance.base_url = nil
+    end
+
+    it 'should have an empty base url by default' do
+      BrowserInstance.base_url.should == ''
+    end
+  
+    it 'should have the base url set by base_url=' do
+      BrowserInstance.base_url = 'http://something'
+      BrowserInstance.base_url.should == 'http://something'
+    end
+  
+    it 'should have a base url provided by environment variable if none has been set by base_url=' do
+      ENV.stub!(:[]).with('BASE_URL').and_return('http://from-environment')
+      BrowserInstance.base_url.should == 'http://from-environment'
+    end
+
+  end
+
+  describe 'browser_instance' do
+
+    before do
+      @driver = stub('firefox driver')
+      class << @driver
+        attr_reader :last_to_location
+        def to(location)
+          @last_to_location = location
+        end
+      end
+      @driver.stub!(:navigate).and_return(@driver)
+      Selenium::WebDriver.stub!(:for).and_return(@driver)
+    end
+
+    after do
+      BrowserInstance.instance_variable_set(:@browser, nil)
+    end
+
+    it 'should create a new WebDriver driver instance for firefox' do
+      Selenium::WebDriver.should_receive(:for).with(:firefox).and_return(@driver)
+      BrowserInstance.browser_instance
+    end 
+
+    it 'should return the created driver from browser_instance' do
+      BrowserInstance.browser_instance.should equal(@driver)
+    end
+
+    describe 'navigate interface' do
+
+      before do
+        BrowserInstance.base_url = 'http://flibble'
+        @browser = BrowserInstance.browser_instance
+      end
+
+      it 'should prepend the base url when to is used' do
+        @browser.navigate.to '/somewhere'
+        @browser.last_to_location.should == 'http://flibble/somewhere'
+      end
+  
+      it 'should ignore the base url when navigate.to_absolute is used' do
+        @browser.navigate.to_absolute '/somewhere'
+        @browser.last_to_location.should == '/somewhere'
+      end
+
+    end
+
+    describe 'when a browser has already been requested' do
+
+      before do
+        BrowserInstance.browser_instance
+      end
+
+      it 'should not create another WebDriver driver instance' do
+        Selenium::WebDriver.should_not_receive(:for)
+        BrowserInstance.browser_instance
+      end
+
+      it 'should return the same instance on subsequent calls' do
+        BrowserInstance.browser_instance.should equal(BrowserInstance.browser_instance)
+      end
+
+    end
+
+  end
+
+end

data/spec/element_reader_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe WebViewer::ElementReader do
+
+  before do
+    @dummy_element = stub('webdriver element')
+    @viewer = stub('viewer', :find_element => @dummy_element)
+  end
+
+  describe 'when the selector is a proc' do
+
+    describe 'and the selector proc has parameters' do
+
+      before do
+        @reader = WebViewer::ElementReader.new(@viewer, proc {|argument| "proc based selector with #{argument}"}, :css)
+      end
+  
+      it 'should require parameters' do
+        @reader.requires_parameters?.should be_true
+      end
+
+      describe '#get' do
+        
+        it 'should return itself if parameters are not provided' do
+          @reader.get.should == @reader
+        end
+
+        it 'should fetch the element from the viewer using the result of calling the proc if parameters are provided' do
+          @viewer.should_receive(:find_element).with(:css, 'proc based selector with parameter value')
+          @reader.get('parameter value')
+        end
+
+        it 'should return the fetched element if parameters are provided' do
+          @reader.get('parameter value').should == @dummy_element
+        end
+
+      end  
+
+      describe '#[]' do
+
+        it 'should fetch the element from the viewer using the result of calling the proc if parameters are provided' do
+          @viewer.should_receive(:find_element).with(:css, 'proc based selector with parameter value')
+          @reader['parameter value']
+        end
+
+        it 'should return the fetched element if parameters are provided' do
+          @reader['parameter value'].should == @dummy_element
+        end
+
+      end
+
+    end
+
+    describe 'and the selector proc has no parameters' do
+
+      before do
+        @reader = WebViewer::ElementReader.new(@viewer, proc {'proc based selector'}, :css)
+      end
+
+      it 'should not require parameters if the selector is a proc with no parameters' do
+        @reader.requires_parameters?.should be_false
+      end
+  
+      it 'should recognize that the selector is callable' do
+        @reader.callable_selector?.should be_true
+      end
+
+      it 'should fetch the element from the viewer using the result of calling the proc' do
+        @viewer.should_receive(:find_element).with(:css, 'proc based selector')
+        @reader.get
+      end
+
+      it 'should return the fetched element' do
+        @reader.get.should == @dummy_element
+      end
+
+    end
+
+  end
+
+  describe 'when the selector is a string' do
+
+    before do
+      @reader = WebViewer::ElementReader.new(@viewer, 'text based selector', :css)
+    end
+
+    it 'should not require parameters if the selector is a string' do
+      @reader.requires_parameters?.should be_false
+    end
+
+    it 'should recognize that the selector is not callable' do
+      @reader.callable_selector?.should be_false
+    end
+
+    it 'should fetch the element from the viewer' do
+      @viewer.should_receive(:find_element).with(:css, 'text based selector')
+      @reader.get
+    end
+
+    it 'should return the fetched element' do
+      @reader.get.should == @dummy_element
+    end
+
+  end
+
+end

data/spec/element_value_reader_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe WebViewer::ElementValueReader do
+
+  share_as :UnimplementedOutputType do
+
+    it 'should raise an exception' do
+      output_type = self.class.options[:output_type]
+      value_reader = WebViewer::ElementValueReader.new(@element_reader, output_type)
+      read_operation = lambda { @element_reader.requires_parameters? ? value_reader['1'] : value_reader.get }
+      read_operation.should raise_error "not yet implemented"
+    end
+
+  end
+
+  describe 'when the element reader does not require parameters' do
+
+    before do
+      @dummy_element = stub(:value => 'element value')
+      @element_reader = stub('element reader', :requires_parameters? => false, :get => @dummy_element)
+    end
+
+    describe 'and the output type is not a class' do
+
+      before do
+        @value_reader = WebViewer::ElementValueReader.new(@element_reader, :value)
+      end
+
+      describe '#get' do
+
+        it 'should fetch the element from the element reader' do
+          @element_reader.should_receive(:get).and_return(@dummy_element)
+          @value_reader.get
+        end
+
+        it 'should call the method on the element with name equal to the output type parameter' do
+          @dummy_element.should_receive(:value)
+          @value_reader.get
+        end
+
+        it 'should return the result of calling the method on the element with name equal to the output type parameter' do
+          @value_reader.get.should == 'element value'
+        end
+
+      end
+
+    end
+
+    describe ('and the type is :auto', :output_type => :auto) { it_should_behave_like UnimplementedOutputType }
+    describe ('and the type is :link', :output_type => :link) { it_should_behave_like UnimplementedOutputType }
+    describe ('and the type is :select_by_text', :output_type => :select_by_text) { it_should_behave_like UnimplementedOutputType }
+    describe ('and the type is :select_by_value', :output_type => :select_by_value) { it_should_behave_like UnimplementedOutputType }
+
+    describe 'and the output type is a class' do
+
+      class FakeViewer
+        attr :base_element_proc
+      end
+
+      before do
+        @value_reader = WebViewer::ElementValueReader.new(@element_reader, FakeViewer)
+      end
+
+      it 'should return an instance of the specified class' do
+        @value_reader.get.should be_instance_of(FakeViewer)
+      end
+
+      it 'should put a base_element_proc instance value into the returned object' do
+        @value_reader.get.base_element_proc.should_not be_nil
+      end
+
+    end
+
+  end
+
+  describe 'when the element reader requires parameters' do
+
+    before do
+      @dummy_element = stub(:value => 'element value')
+      @element_reader = stub('element reader', :requires_parameters? => true, :get => @dummy_element)
+    end
+
+    describe 'and the output type is not a class' do
+
+      before do
+        @value_reader = WebViewer::ElementValueReader.new(@element_reader, :value)
+      end
+
+      it '#get should return the element value reader' do
+        @value_reader.get.should == @value_reader
+      end
+
+      describe '#[]' do
+
+        it 'should fetch the element from the element reader passing provided parameters' do
+          @element_reader.should_receive(:get).with(1, 2, 3).and_return(@dummy_element)
+          @value_reader[1, 2, 3]
+        end
+
+        it 'should call the method on the element with name equal to the output type parameter' do
+          @dummy_element.should_receive(:value)
+          @value_reader[1]
+        end
+
+        it 'should return the result of calling the method on the element with name equal to the output type parameter' do
+          @value_reader[1].should == 'element value'
+        end
+
+      end
+
+      describe '#[]=' do
+
+        before do
+          @fake_value_writer = stub(:value= => nil)
+          WebViewer::ElementValueWriter.stub(:new).and_return(@fake_value_writer)
+        end
+
+        it 'should get the element from the element reader using all parameters except the assigned value' do
+          @element_reader.should_receive(:get).with(1, 2, 3).and_return(@dummy_element)
+          @value_reader[1, 2, 3] = 4
+        end
+
+        it 'should create an element value writer with the element and output type' do
+          WebViewer::ElementValueWriter.should_receive(:new).with(@dummy_element, :value)
+          @value_reader[1, 2, 3] = 4
+        end
+
+        it 'should assign the value to the writer using value=' do
+          @fake_value_writer.should_receive(:value=).with(4)
+          @value_reader[1, 2, 3] = 4
+        end
+
+      end
+
+    end
+
+    describe ('and the type is :auto', :output_type => :auto) { it_should_behave_like UnimplementedOutputType }
+    describe ('and the type is :link', :output_type => :link) { it_should_behave_like UnimplementedOutputType }
+    describe ('and the type is :select_by_text', :output_type => :select_by_text) { it_should_behave_like UnimplementedOutputType }
+    describe ('and the type is :select_by_value', :output_type => :select_by_value) { it_should_behave_like UnimplementedOutputType }
+
+    describe 'and the output type is a class' do
+
+      before do
+        @value_reader = WebViewer::ElementValueReader.new(@element_reader, FakeViewer)
+      end
+
+      it 'should return an instance of the specified class' do
+        @value_reader[1, 2].should be_instance_of(FakeViewer)
+      end
+
+      it 'should put a base_element_proc instance value that gets the element from the reader into the returned object' do
+        @element_reader.should_receive(:get).with(1, 2)
+        @value_reader[1, 2].base_element_proc.call
+      end
+
+    end
+
+  end
+
+end

data/spec/element_value_writer_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe WebViewer::ElementValueWriter do
+
+  describe "#value=" do
+
+    it 'should assign the new value to its web element using value=' do
+      web_element = stub('WebDriver::Element')
+      writer = WebViewer::ElementValueWriter.new(web_element, :value)
+      web_element.should_receive(:value=).with('new value')
+      writer.value = 'new value'
+    end
+
+  end
+
+end

data/spec/page_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe 'an object that includes WebPage' do
+
+  class SampleWebPage
+    include WebPage
+  end
+
+  before do
+    @page = SampleWebPage.new
+    @page.stub!(:navigate).and_return(stub('navigate interface'))
+  end
+
+  it 'should not have a url instance method if the url class method has not been called' do
+    @page.respond_to?(:url).should == false
+  end
+
+  it 'should not have a path instance method if the path class method has not been called' do
+    @page.respond_to?(:path).should == false
+  end
+
+  describe 'with a url set using the .url class method' do
+
+    before do
+      class << @page
+        url 'http://somewhere'
+      end
+    end
+
+    it 'should return the value from #url that was set by .url' do
+      @page.url.should == 'http://somewhere'
+    end
+
+    it 'should navigate to the absolute url when load is called' do
+      @page.navigate.should_receive(:to_absolute).with('http://somewhere')
+      @page.load
+    end
+
+  end
+
+  describe 'with a url set using the .url class method' do
+  
+    before do
+      class << @page
+        path '/somewhere'
+      end
+    end
+  
+    it 'should return the value from #path that was set by .path' do
+      @page.path.should == '/somewhere'
+    end
+
+    it 'should navigate to the relative path when load is called' do
+      @page.navigate.should_receive(:to_relative).with('/somewhere')
+      @page.load
+    end
+
+  end
+
+  it 'should construct itself and call #load when .load is called' do
+    SampleWebPage.stub!(:new).and_return(@page)
+    @page.should_receive(:load)
+    SampleWebPage.load
+  end
+
+end

data/spec/selenium-webdriver-viewers_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "SeleniumWebdriverViewers" do
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--format specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'selenium-webdriver-viewers'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/viewer_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe WebViewer, 'included in a class' do
+
+  before do
+    @viewer_class = Class.new(Object).extend(WebViewer)
+  end
+
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification 
+name: selenium-webdriver-viewers
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michael Collas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-16 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: reek
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 2
+        - 8
+        version: 1.2.8
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sexp_processor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 0
+        - 4
+        version: 3.0.4
+  type: :development
+  version_requirements: *id003
+description: "      This gem makes it easy to create page and web viewer objects for use by tests that use selenium-webdriver. By\n      using page and viewer objects, you can decouple your tests from the html details so that they can focus\n      instead on describing the behaviour of your application. \n"
+email: mcollas@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+- TODO
+files: 
+- .document
+- LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION
+- lib/browser-instance.rb
+- lib/element_reader.rb
+- lib/element_value_reader.rb
+- lib/element_value_writer.rb
+- lib/page.rb
+- lib/selenium-webdriver-viewers.rb
+- lib/viewer.rb
+- lib/webdriver-extensions.rb
+- selenium-webdriver-viewers.gemspec
+- spec/browser-instance_spec.rb
+- spec/element_reader_spec.rb
+- spec/element_value_reader_spec.rb
+- spec/element_value_writer_spec.rb
+- spec/page_spec.rb
+- spec/selenium-webdriver-viewers_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/viewer_spec.rb
+has_rdoc: true
+homepage: http://github.com/michaelcollas/selenium-webdriver-viewers
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Makes page objects and views for tests using selenium-webdriver.
+test_files: 
+- spec/browser-instance_spec.rb
+- spec/element_reader_spec.rb
+- spec/element_value_reader_spec.rb
+- spec/element_value_writer_spec.rb
+- spec/page_spec.rb
+- spec/selenium-webdriver-viewers_spec.rb
+- spec/spec_helper.rb
+- spec/viewer_spec.rb