jtzemp-tourbus 0.0.9

data/lib/web-sickle/lib/web_sickle.rb

@@ -0,0 +1,227 @@
+class WebsickleException < Exception; end
+
+module WebSickle
+  # form_value is used to interface with the current select form
+  attr_reader :form_value
+  attr_accessor :page
+  
+  def initialize(options = {})
+    @page = nil
+    @form_value = HashProxy.new(
+      :set => lambda { |identifier, value| set_form_value(identifier, value)}, 
+      :get => lambda { |identifier| get_form_value(identifier)}
+    )
+  end
+  
+  def click_link(link)
+    set_page(agent.click(find_link(link)))
+  end
+  
+  def submit_form(options = {})
+    options[:button] = :first unless options.has_key?(:button)
+    options[:identified_by] ||= :first
+    select_form(options[:identified_by])
+    set_form_values(options[:values]) if options[:values]
+    submit_form_button(options[:button])
+  end
+
+  # select the current form
+  def select_form(identifier = {})
+    identifier = make_identifier(identifier, [:name, :action, :method])
+    @form = find_in_collection(@page.forms, identifier)
+    unless @form
+      valid_forms = @page.forms.map {|f| "name: #{f.name}, method: #{f.method}, action: #{f.action}"} * "\n"
+      report_error("Couldn't find form on page at #{@page.uri} with attributes #{identifier.inspect}. Valid forms on this page are: \n#{valid_forms}")
+    end
+    @form
+  end
+  
+  # submits the current form
+  def submit_form_button(button_criteria = nil, options = {})
+    button = 
+      case button_criteria
+      when nil
+        nil
+      else
+        find_button(button_criteria)
+      end
+    set_page(agent.submit(@form, button))
+  end
+
+  # sets the given path to the current page, then opens it using our agent
+  def open_page(path, parameters = [], referer = nil)
+    set_page(agent.get(path, parameters, referer))
+  end
+
+  # uses Hpricot style css selectors to find the elements in the current +page+.
+  # Uses Hpricot#/ (or Hpricot#search)
+  def select_element(match)
+    select_element_in(@page, match)
+  end
+  
+  # uses Hpricot style css selectors to find the element in the given container.  Works with html pages, and file pages that happen to have xml-like content.
+  # throws error if can't find a match
+  def select_element_in(contents, match)
+    result = (contents.respond_to?(:/) ? contents : Hpricot(contents.body)) / match
+    if result.blank?
+      report_error("Tried to find element matching #{match}, but couldn't")
+    else
+      result
+    end
+  end
+
+  # uses Hpricot style css selectors to find the element.  Works with html pages, and file pages that happen to have xml-like content.
+  # throws error if can't find a match
+  # Uses Hpricot#at
+  def detect_element(match)
+    result = (@page.respond_to?(:at) ? @page : Hpricot(@page.body)).at(match)
+    if result.blank?
+      report_error("Tried to find element matching #{match}, but couldn't")
+    else
+      result
+    end
+  end
+  
+  protected
+    # our friendly mechinze agent
+    def agent
+      @agent ||= new_mechanize_agent
+    end
+    
+    def make_identifier(identifier, valid_keys = nil, default_key = :name)
+      identifier = {default_key => identifier} unless identifier.is_a?(Hash) || identifier.is_a?(Symbol)
+      identifier.assert_valid_keys(valid_keys) if identifier.is_a?(Hash) && valid_keys
+      identifier
+    end
+  
+    def find_field(identifier)
+      if @form.nil?
+        report_error("No form is selected when trying to find field by #{identifier.inspect}")
+        return
+      end
+      identifier = make_identifier(identifier, [:name, :value])
+      find_in_collection(@form.radiobuttons + @form.fields + @form.checkboxes + @form.file_uploads, identifier) ||
+        report_error("Tried to find field identified by #{identifier.inspect}, but failed.\nForm fields are: #{(@form.radiobuttons + @form.fields + @form.checkboxes + @form.file_uploads).map{|f| f.name} * ", \n  "}") 
+    end
+    
+    def find_link(identifier)
+      identifier = make_identifier(identifier, [:href, :text], :text)
+      find_in_collection(page.links, identifier) ||
+        report_error("Tried to find link identified by #{identifier.inspect}, but failed.\nValid links are: #{page.links.map{|f| f.inspect} * ", \n  "}")
+    end
+  
+    # finds a button by parameters.  Throws error if not able to find.
+    # example:
+    # find_button("btnSubmit") - finds a button named "btnSubmit"
+    # find_button(:name => "btnSubmit")
+    # find_button(:name => "btnSubmit", :value => /Lucky/) - finds a button named btnSubmit with a value matching /Lucky/
+    def find_button(identifier)
+      identifier = make_identifier(identifier, [:value, :name])
+      find_in_collection(@form.buttons, identifier) ||
+        report_error("Tried to find button identified by #{identifier.inspect}, but failed.  Buttons on selected form are: #{@form.buttons.map{|f| f.name} * ','}")
+    end
+  
+    # the magic method that powers find_button, find_field.  Does not throw an error if not found
+    def find_in_collection(collection, identifier, via = :find)
+      return collection.first if identifier == :first
+      find_all_in_collection(collection, identifier, :find)
+    end
+    
+    def find_all_in_collection(collection, identifier, via = :select)
+      return [collection.first] if identifier == :first
+      collection.send(via) do |item|
+        identifier.all? { |k, criteria| is_a_match?(criteria, item.send(k)) }
+      end
+    end
+
+    # sets a form-field's value by identifier.  Throw's error if field does not exist
+    def set_form_value(identifier, value)
+      field = find_field(identifier)
+      case field
+      when WWW::Mechanize::Form::CheckBox
+        field.checked = value
+      when WWW::Mechanize::Form::RadioButton
+        radio_collection = find_all_in_collection(@form.radiobuttons, :name => field.name)
+        radio_collection.each { |f|; f.checked = false }
+        finder = (value.is_a?(Hash) || value.is_a?(Symbol)) ? value : {:value => value}
+        find_in_collection(radio_collection, finder).checked = true
+      when WWW::Mechanize::Form::SelectList
+        if value.is_a?(Hash) || value.is_a?(Symbol)
+          field.value = find_in_collection(field.options, value).value
+        else
+          field.value = value
+        end
+      else
+        field.value = value
+      end
+    end
+  
+    def set_form_values(set_pairs = {})
+      flattened_value_hash(set_pairs).each do |identifier, value|
+        set_form_value(identifier, value)
+      end
+    end
+    
+    def flattened_value_hash(hash, parents = [])
+      new_hash = {}
+      hash.each do |key, value|
+        if value.is_a?(Hash) && value.keys.first.is_a?(String)
+          new_hash.update(flattened_value_hash(value, [key] + parents))
+        else
+          parents.each { |parent| key = "#{parent}[#{key}]"}
+          new_hash[key] = value
+        end
+      end
+      new_hash
+    end
+
+    # sets a form-field's value by identifier.  Throw's error if field does not exist
+    def get_form_value(identifier)
+      field = find_field(identifier)
+      case field
+      when WWW::Mechanize::Form::CheckBox
+        field.checked
+      else
+        field.value
+      end
+    end
+    
+    def format_error(msg)
+      error = "Error encountered: #{msg}."
+      begin
+        error << "\n\nPage URL:#{@page.uri.to_s}" if @page
+      rescue
+      end
+      error
+    end
+
+    def report_error(msg)
+      raise WebsickleException, format_error(msg)
+      nil
+    end
+    
+  private
+    def set_page(p)
+      @form = nil
+      @page = p
+    end
+
+    def is_a_match?(criteria, value)
+      case criteria
+      when Regexp
+        criteria.match(value)
+      when String
+        criteria == value
+      when Array
+        criteria.include?(value)
+      else
+        criteria.to_s == value.to_s
+      end
+    end
+  
+    def new_mechanize_agent
+      a = WWW::Mechanize.new
+      a.read_timeout = 600 # 10 minutes
+      a
+    end
+end

data/lib/web-sickle/spec/lib/helpers/table_reader_spec.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe WebSickle::Helpers::TableReader do
+  describe "Simple example" do
+    before(:each) do
+      @content = <<-EOF
+        <table>
+          <tr>
+            <th>Name</th>
+            <th>Age</th>
+          </tr>
+          <tr>
+            <td>Googly</td>
+            <td>2</td>
+          </tr>
+        </table>    
+      EOF
+      h = Hpricot(@content)
+      @table = WebSickle::Helpers::TableReader.new(h / "table")
+    end
+  
+    it "should extract headers" do
+      @table.headers.should == ["Name", "Age"]
+    end
+  
+    it "should extract rows" do
+      @table.rows.should == [
+        {"Name" => "Googly", "Age" => "2"}
+      ]
+    end
+  end
+  
+  
+  
+  describe "Targetted example" do
+    before(:each) do
+      @content = <<-EOF
+        <table>
+          <thead>
+            <tr>
+              <td colspan='2'>----</td>
+            </tr>
+            <tr>
+              <th><b>Name</b></th>
+              <th><b>Age</b></th>
+            </tr>
+          </thead>
+          <tbody>  
+            <tr>
+              <td>Googly</td>
+              <td>2</td>
+            </tr>
+            <tr>
+              <td>Bear</td>
+              <td>3</td>
+            </tr>
+            <tr>
+              <td colspan='2'>Totals!</td>
+            </tr>
+            <tr>
+              <td>---</td>
+              <td>5</td>
+            </tr>
+          </tbody>
+        </table>    
+      EOF
+      h = Hpricot(@content)
+      @table = WebSickle::Helpers::TableReader.new(h / " > table",
+        :header_selector => " > th > b",
+        :header_offset => 1,
+        :body_range => 2..-3
+      )
+    end
+    
+    it "should extract the column headers" do
+      @table.headers.should == ["Name", "Age"]
+    end
+    
+    it "should extract the row data for the specified range" do
+      @table.rows.should == [
+        {"Name" => "Googly", "Age" => "2"},
+        {"Name" => "Bear", "Age" => "3"},
+      ]
+    end
+    
+    it "should allow you to check extra rows to assert you didn't chop off too much" do
+      (@table.extra_rows.first / "td").inner_text.should == "Totals!"
+    end
+  end
+  
+  
+  
+  describe "when using procs to extract data" do
+    before(:each) do
+      @content = <<-EOF
+        <table>
+          <tr>
+            <th>Name</th>
+            <th>Age</th>
+          </tr>
+          <tr>
+            <td>Googly</td>
+            <td>2</td>
+          </tr>
+          <tr>
+            <td>Bear</td>
+            <td>3</td>
+          </tr>
+        </table>    
+      EOF
+      h = Hpricot(@content)
+      @table = WebSickle::Helpers::TableReader.new(h / " > table",
+        :header_proc => lambda {|th| th.inner_text.downcase.to_sym},
+        :body_proc => lambda {|col_name, td| 
+          value = td.inner_text
+          case col_name
+          when :name
+            value.upcase
+          when :age
+            value.to_i
+          end
+        }
+      )
+    end
+    
+    it "should use the header proc to extract column headers" do
+      @table.headers.should == [:name, :age]
+    end
+    
+    it "should use the body proc to format the data" do
+      @table.rows.should == [
+        {:name => "GOOGLY", :age => 2},
+        {:name => "BEAR", :age => 3}
+      ]
+    end
+  end
+end

data/lib/web-sickle/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../init.rb'
+require 'rubygems'
+require 'hpricot'
+require 'test/unit'
+require 'spec'
+require 'active_support'
+require File.dirname(__FILE__) + '/spec_helpers/mechanize_mock_helper.rb'

data/lib/web-sickle/spec/spec_helpers/mechanize_mock_helper.rb

@@ -0,0 +1,12 @@
+module MechanizeMockHelper
+  def fixture_file(filename)
+    File.read("#{File.dirname(__FILE__)}/../fixtures/#{filename}")
+  end
+  
+  def mechanize_page(path_to_data, options = {})
+    options[:uri] ||= URI.parse("http://url.com/#{path_to_data}")
+    options[:response] ||= {'content-type' => 'text/html'}
+  
+    WWW::Mechanize::Page.new(options[:uri], options[:response], fixture_file("/#{path_to_data}"))
+  end
+end

data/lib/web-sickle/spec/web_sickle_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class WebSickleHelper
+  include WebSickle
+end
+
+describe WebSickle do
+  include MechanizeMockHelper
+  
+  before(:all) do
+    WebSickleHelper.protected_instance_methods.each do |method|
+      WebSickleHelper.send(:public, method)
+    end
+  end
+  
+  before(:each) do
+    @helper = WebSickleHelper.new
+  end
+  
+  it "should flatten a value hash" do
+    @helper.flattened_value_hash("contact" => {"first_name" => "bob"}).should == {"contact[first_name]" => "bob"}
+  end
+  
+  describe "clicking links" do
+    before(:each) do
+      @helper.stub!(:page).and_return(mechanize_page("linkies.html"))
+    end
+    
+    it "should click a link by matching the link text" do
+      @helper.agent.should_receive(:click) do |link|
+        link.text.should include("one")
+      end
+      @helper.click_link(:text => /one/)
+    end
+    
+    it "should click a link by matching the link href" do
+      @helper.agent.should_receive(:click) do |link|
+        link.href.should include("/two")
+      end
+      @helper.click_link(:href => %r{/two})
+    end
+    
+    it "should default matching the link text" do
+      @helper.agent.should_receive(:click) do |link|
+        link.text.should include("Link number one")
+      end
+      @helper.click_link("Link number one")
+    end
+  end
+end

data/lib/web_sickle_webrat_adapter.rb

@@ -0,0 +1,40 @@
+require 'webrat'
+require 'webrat/mechanize'
+
+module WebSickleWebratAdapter
+
+  def open_page(url)
+    session.visit(url)
+  end
+
+  def click_link(options)
+    raise "This adapter only works with the :text option!" unless options[:text]
+    session.click_link(options[:text])
+  end
+
+  def submit_form_with_options(options_hash)
+    action = options_hash[:identified_by][:action]
+    raise "You must provide an action!" unless action
+    action_regexp = action.is_a?(Regexp) ? action : Regexp.new("#{action}$")
+    form = page.forms.detect {|f| f.action =~ action_regexp }
+    raise "Could not find form with matching action: #{action_regexp}" unless form
+    method = options_hash[:method] || 'post'
+    session.request_page(form.action, method, options_hash[:values])
+  end
+
+  def page
+    session.response
+  end
+  
+  # def visit(url)
+  #   session.visit(url)
+  # end
+
+  private
+
+  def session
+    @session ||= Webrat::MechanizeSession.new
+  end
+
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: jtzemp-tourbus
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+platform: ruby
+authors: 
+- David Brady
+- James Britt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-17 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: faker
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: TourBus, a web stress-testing tool that combines complex 'tour' definitions with scalable concurrent testing
+email: github@shinybit.com
+executables: 
+- tourbus
+- tourwatch
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+- examples/contact_app/README.rdoc
+files: 
+- bin/tourbus
+- bin/tourwatch
+- examples/contact_app/README.rdoc
+- examples/contact_app/contact_app.rb
+- examples/contact_app/tours/simple.rb
+- examples/contact_app/tours/tourbus.yml
+- lib/common.rb
+- lib/runner.rb
+- lib/tour.rb
+- lib/tour_bus.rb
+- lib/tour_watch.rb
+- lib/web_sickle_webrat_adapter.rb
+- lib/web-sickle/init.rb
+- lib/web-sickle/lib/assertions.rb
+- lib/web-sickle/lib/hash_proxy.rb
+- lib/web-sickle/lib/helpers/asp_net.rb
+- lib/web-sickle/lib/helpers/table_reader.rb
+- lib/web-sickle/lib/make_nokigiri_output_useful.rb
+- lib/web-sickle/lib/web_sickle.rb
+- lib/web-sickle/spec/lib/helpers/table_reader_spec.rb
+- lib/web-sickle/spec/spec_helper.rb
+- lib/web-sickle/spec/spec_helpers/mechanize_mock_helper.rb
+- lib/web-sickle/spec/web_sickle_spec.rb
+- README.rdoc
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://github.com/dbrady/tourbus/
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+- --title
+- Tourbus - Web Stress Testing in Ruby
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TourBus web stress-testing tool
+test_files: []
+