benschwarz-webrat 0.3.2.1

data/lib/webrat/merb.rb

@@ -0,0 +1,77 @@
+require "webrat"
+
+require "cgi"
+gem "extlib"
+require "extlib"
+require "merb-core"
+
+HashWithIndifferentAccess = Mash
+
+module Webrat
+  class MerbSession < Session #:nodoc:
+    include Merb::Test::MakeRequest
+    
+    attr_accessor :response
+    
+    def get(url, data, headers = nil)
+      do_request(url, data, headers, "GET")
+    end
+  
+    def post(url, data, headers = nil)
+      do_request(url, data, headers, "POST")
+    end
+  
+    def put(url, data, headers = nil)
+      do_request(url, data, headers, "PUT")
+    end
+  
+    def delete(url, data, headers = nil)
+      do_request(url, data, headers, "DELETE")
+    end
+    
+    def response_body
+      @response.body.to_s
+    end
+    
+    def response_code
+      @response.status
+    end
+    
+    def do_request(url, data, headers, method)
+      @response = request(url, 
+        :params => (data && data.any?) ? data : nil, 
+        :headers => headers,
+        :method => method)
+      follow_redirect
+    end
+    
+    def follow_redirect
+      self.get(@response.headers['Location'], nil, @response.headers) if @response.status == 302
+    end
+
+  end
+end
+
+module Merb #:nodoc:
+  module Test #:nodoc:
+    module RequestHelper #:nodoc:
+      def request(uri, env = {})
+        @_webrat_session ||= Webrat::MerbSession.new
+        @_webrat_session.response = @_webrat_session.request(uri, env)
+      end
+  
+      def follow_redirect
+        @_webrat_session.follow_redirect
+      end
+    end
+  end
+end
+
+class Merb::Test::RspecStory #:nodoc:
+  def browser
+    @browser ||= Webrat::MerbSession.new
+  end
+end
+
+Webrat.configuration.mode = :merb
+

data/lib/webrat/rack.rb

@@ -0,0 +1,26 @@
+require 'webrat'
+
+class CGIMethods #:nodoc:
+  def self.parse_query_parameters(params)
+    hash = {}
+    params.split('&').each do |p|
+      pair = p.split('=')
+      hash[pair[0]] = pair[1]
+    end
+    hash
+  end
+end
+
+module Webrat
+  class RackSession < Session #:nodoc:
+    def response_body
+      @response.body
+    end
+
+    def response_code
+      @response.status
+    end
+  end
+end
+
+Webrat.configuration.mode = :rack

data/lib/webrat/rails.rb

@@ -0,0 +1,88 @@
+require "webrat"
+require "action_controller/integration"
+
+module Webrat
+  class RailsSession < Session #:nodoc:
+
+    def doc_root
+      File.expand_path(File.join(RAILS_ROOT, 'public'))
+    end
+    
+    def saved_page_dir
+      File.expand_path(File.join(RAILS_ROOT, "tmp"))
+    end
+    
+    def get(url, data, headers = nil)
+      do_request(:get, url, data, headers)
+    end
+    
+    def post(url, data, headers = nil)
+      do_request(:post, url, data, headers)
+    end
+    
+    def put(url, data, headers = nil)
+      do_request(:put, url, data, headers)
+    end
+    
+    def delete(url, data, headers = nil)
+      do_request(:delete, url, data, headers)
+    end
+    
+    def response_body
+      response.body
+    end
+    
+    def response_code
+      response.code.to_i
+    end
+    
+  protected
+    
+    def integration_session
+      @context
+    end
+    
+    def do_request(http_method, url, data, headers) #:nodoc:
+      update_protocol(url)
+      integration_session.request_via_redirect(http_method, remove_protocol(url), data, headers)
+    end
+  
+    def remove_protocol(href) #:nodoc:
+      if href =~ %r{^https?://www.example.com(/.*)}
+        $LAST_MATCH_INFO.captures.first
+      else
+        href
+      end
+    end
+    
+    def update_protocol(href) #:nodoc:
+      if href =~ /^https:/
+        integration_session.https!(true)
+      elsif href =~ /^http:/
+        integration_session.https!(false)
+      end
+    end
+    
+    def response #:nodoc:
+      integration_session.response
+    end
+    
+  end
+end
+
+module ActionController #:nodoc:
+  module Integration #:nodoc:
+    Session.class_eval do
+      unless instance_methods.include?("put_via_redirect")
+        require "webrat/rails/redirect_actions"
+        include Webrat::RedirectActions
+      end
+    end
+  end
+  
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+  end
+end
+
+Webrat.configuration.mode = :rails

data/lib/webrat/rails/redirect_actions.rb

@@ -0,0 +1,18 @@
+# For Rails before http://dev.rubyonrails.org/ticket/10497 was committed
+module Webrat
+  module RedirectActions #:nodoc:
+    
+    def put_via_redirect(path, parameters = {}, headers = {})
+      put path, parameters, headers
+      follow_redirect! while redirect?
+      status
+    end
+
+    def delete_via_redirect(path, parameters = {}, headers = {})
+      delete path, parameters, headers
+      follow_redirect! while redirect?
+      status
+    end
+    
+  end
+end

data/lib/webrat/rspec-rails.rb

@@ -0,0 +1,13 @@
+# Supports using the matchers in controller, helper, and view specs if you're
+# using rspec-rails. Just add a require statement to spec/spec_helper.rb:
+# 
+#   require 'webrat/rspec-rails'
+#
+require "webrat/core/matchers"
+
+Spec::Runner.configure do |config|
+  # rspec should support :type => [:controller, :helper, :view] - but until it does ...
+  config.include(Webrat::Matchers, :type => :controller)
+  config.include(Webrat::Matchers, :type => :helper)
+  config.include(Webrat::Matchers, :type => :view)
+end

data/lib/webrat/selenium.rb

@@ -0,0 +1,58 @@
+require "webrat"
+gem "selenium-client", ">=1.2.9"
+require "selenium/client"
+require "webrat/selenium/selenium_session"
+
+Webrat.configuration.mode = :selenium
+
+module Webrat
+  
+  def self.with_selenium_server #:nodoc:
+    start_selenium_server
+    yield
+    stop_selenium_server
+  end
+  
+  def self.start_selenium_server #:nodoc:
+    @remote_control ||= ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0", 4444, 5)
+    @remote_control.jar_file = File.expand_path(__FILE__ + "../../../../vendor/selenium-server.jar")
+    @remote_control.start :background => true
+    TCPSocket.wait_for_service :host => "0.0.0.0", :port => 4444
+  end
+  
+  def self.stop_selenium_server #:nodoc:
+    @remote_control.stop
+  end
+  
+  def self.start_app_server #:nodoc:
+    pid_file = File.expand_path(RAILS_ROOT + "/tmp/pids/mongrel_selenium.pid")
+    system("mongrel_rails start -d --chdir=#{RAILS_ROOT} --port=3001 --environment=selenium --pid #{pid_file} &")
+    TCPSocket.wait_for_service :host => "0.0.0.0", :port => 3001
+  end
+  
+  def self.stop_app_server #:nodoc:
+    pid_file = File.expand_path(RAILS_ROOT + "/tmp/pids/mongrel_selenium.pid")
+    system "mongrel_rails stop -c #{RAILS_ROOT} --pid #{pid_file}"
+  end
+  
+  module Selenium #:nodoc:
+    module Rails #:nodoc:
+      class World < ::ActionController::IntegrationTest
+        
+        def initialize #:nodoc:
+          @_result = Test::Unit::TestResult.new
+        end
+        
+      end
+    end
+  end
+    
+end
+
+module ::ActionController #:nodoc:
+  module Integration #:nodoc:
+    class Session #:nodoc:
+      include Webrat::Methods
+    end
+  end
+end

data/lib/webrat/selenium/location_strategy_javascript/button.js

@@ -0,0 +1,12 @@
+if (locator == '*') {
+  return selenium.browserbot.locationStrategies['xpath'].call(this, "//input[@type='submit']", inDocument, inWindow)
+}
+var inputs = inDocument.getElementsByTagName('input');
+return $A(inputs).find(function(candidate){
+  inputType = candidate.getAttribute('type');
+  if (inputType == 'submit' || inputType == 'image') {
+    var buttonText = $F(candidate);
+    return (PatternMatcher.matches(locator, buttonText));
+  }
+  return false;
+});

data/lib/webrat/selenium/location_strategy_javascript/label.js

@@ -0,0 +1,16 @@
+var allLabels = inDocument.getElementsByTagName("label");
+var candidateLabels = $A(allLabels).select(function(candidateLabel){
+  var regExp = new RegExp('^' + locator + '\\b', 'i');
+  var labelText = getText(candidateLabel).strip();
+  return (labelText.search(regExp) >= 0);
+});
+if (candidateLabels.length == 0) {
+  return null;      
+}
+candidateLabels = candidateLabels.sortBy(function(s) { return s.length * -1; }); //reverse length sort
+var locatedLabel = candidateLabels.first();
+var labelFor = locatedLabel.getAttribute('for');
+if ((labelFor == null) && (locatedLabel.hasChildNodes())) {
+  return locatedLabel.firstChild; //TODO: should find the first form field, not just any node
+}
+return selenium.browserbot.locationStrategies['id'].call(this, labelFor, inDocument, inWindow);

data/lib/webrat/selenium/location_strategy_javascript/webrat.js

@@ -0,0 +1,5 @@
+var locationStrategies = selenium.browserbot.locationStrategies;
+return locationStrategies['id'].call(this, locator, inDocument, inWindow)
+        || locationStrategies['name'].call(this, locator, inDocument, inWindow)
+        || locationStrategies['label'].call(this, locator, inDocument, inWindow)
+        || null;

data/lib/webrat/selenium/location_strategy_javascript/webratlink.js

@@ -0,0 +1,9 @@
+var links = inDocument.getElementsByTagName('a');
+var candidateLinks = $A(links).select(function(candidateLink) {
+  return PatternMatcher.matches(locator, getText(candidateLink));
+});
+if (candidateLinks.length == 0) {
+  return null;
+}
+candidateLinks = candidateLinks.sortBy(function(s) { return s.length * -1; }); //reverse length sort
+return candidateLinks.first();

data/lib/webrat/selenium/location_strategy_javascript/webratlinkwithin.js

@@ -0,0 +1,15 @@
+var locatorParts = locator.split('|');
+var cssAncestor = locatorParts[0];
+var linkText = locatorParts[1];
+var matchingElements = cssQuery(cssAncestor, inDocument);
+var candidateLinks = matchingElements.collect(function(ancestor){
+  var links = ancestor.getElementsByTagName('a');
+  return $A(links).select(function(candidateLink) {
+    return PatternMatcher.matches(linkText, getText(candidateLink));
+  });
+}).flatten().compact();
+if (candidateLinks.length == 0) {
+  return null;
+}
+candidateLinks = candidateLinks.sortBy(function(s) { return s.length * -1; }); //reverse length sort
+return candidateLinks.first();

data/lib/webrat/selenium/location_strategy_javascript/webratselectwithoption.js

@@ -0,0 +1,5 @@
+var optionElements = inDocument.getElementsByTagName('option');
+var locatedOption = $A(optionElements).find(function(candidate){
+  return (PatternMatcher.matches(locator, getText(candidate)));
+});
+return locatedOption ? locatedOption.parentNode : null;

data/lib/webrat/selenium/selenium_extensions.js

@@ -0,0 +1,6 @@
+PatternMatcher.strategies['evalregex'] = function(regexpString) {
+  this.regexp = eval(regexpString);
+  this.matches = function(actual) {
+    return this.regexp.test(actual);
+  };
+};

data/lib/webrat/selenium/selenium_session.rb

@@ -0,0 +1,186 @@
+module Webrat
+  class SeleniumSession
+    
+    def initialize(*args) # :nodoc:
+      extend_selenium
+      define_location_strategies
+    end
+    
+    def visit(url)
+      selenium.open(url)
+    end
+    
+    webrat_deprecate :visits, :visit
+    
+    def fill_in(field_identifier, options)
+      locator = "webrat=#{Regexp.escape(field_identifier)}"
+      selenium.type(locator, "#{options[:with]}")
+    end
+    
+    webrat_deprecate :fills_in, :fill_in
+    
+    def response_body #:nodoc:
+      selenium.get_html_source
+    end
+    
+    def click_button(button_text_or_regexp = nil, options = {})
+      if button_text_or_regexp.is_a?(Hash) && options == {}
+        pattern, options = nil, button_text_or_regexp
+      else
+        pattern = adjust_if_regexp(button_text_or_regexp)
+      end
+      pattern ||= '*'
+      selenium.click("button=#{pattern}")
+      wait_for_result(options[:wait])
+    end
+    
+    webrat_deprecate :clicks_button, :click_button
+
+    def click_link(link_text_or_regexp, options = {})
+      pattern = adjust_if_regexp(link_text_or_regexp)
+      selenium.click("webratlink=#{pattern}")
+      wait_for_result(options[:wait])
+    end
+    
+    webrat_deprecate :clicks_link, :click_link
+    
+    def click_link_within(selector, link_text, options = {})
+      selenium.click("webratlinkwithin=#{selector}|#{link_text}")
+      wait_for_result(options[:wait])
+    end
+    
+    webrat_deprecate :clicks_link_within, :click_link_within
+
+    def wait_for_result(wait_type)
+      if wait_type == :ajax
+        wait_for_ajax
+      elsif wait_type == :effects
+        wait_for_effects
+      else
+        wait_for_page_to_load
+      end
+    end
+
+    def wait_for_page_to_load(timeout = 15000)
+      selenium.wait_for_page_to_load(timeout)
+    end
+
+    def wait_for_ajax(timeout = 15000)
+      selenium.wait_for_condition "Ajax.activeRequestCount == 0", timeout
+    end
+
+    def wait_for_effects(timeout = 15000)
+      selenium.wait_for_condition "window.Effect.Queue.size() == 0", timeout
+    end
+
+    def wait_for_ajax_and_effects
+      wait_for_ajax
+      wait_for_effects
+    end    
+    
+    def select(option_text, options = {})
+      id_or_name_or_label = options[:from]
+      
+      if id_or_name_or_label
+        select_locator = "webrat=#{id_or_name_or_label}"
+      else
+        select_locator = "webratselectwithoption=#{option_text}"
+      end
+      selenium.select(select_locator, option_text)
+    end
+    
+    webrat_deprecate :selects, :select
+    
+    def choose(label_text)
+      selenium.click("webrat=#{label_text}")
+    end
+    
+    webrat_deprecate :chooses, :choose
+        
+    def check(label_text)
+      selenium.check("webrat=#{label_text}")
+    end
+    
+    webrat_deprecate :checks, :check
+    
+    def is_ordered(*args) #:nodoc:
+      selenium.is_ordered(*args)
+    end
+    
+    def dragdrop(*args) #:nodoc:
+      selenium.dragdrop(*args)
+    end
+
+    def fire_event(field_identifier, event)
+      locator = "webrat=#{Regexp.escape(field_identifier)}"
+      selenium.fire_event(locator, "#{event}")
+    end
+    
+    def key_down(field_identifier, key_code)
+      locator = "webrat=#{Regexp.escape(field_identifier)}"
+      selenium.key_down(locator, key_code)
+    end
+
+    def key_up(field_identifier, key_code)
+      locator = "webrat=#{Regexp.escape(field_identifier)}"
+      selenium.key_up(locator, key_code)
+    end
+    
+    def browser
+      return $browser if $browser
+      setup
+      $browser
+    end
+    
+  protected
+    
+    def setup #:nodoc:
+      silence_stream(STDOUT) do
+        Webrat.start_selenium_server
+        Webrat.start_app_server
+      end
+      
+      
+      $browser = ::Selenium::Client::Driver.new("localhost", 4444, "*firefox", "http://0.0.0.0:3001")
+      $browser.set_speed(0)
+      $browser.start
+      teardown_at_exit
+    end
+    
+    def selenium #:nodoc:
+      browser
+    end
+    
+    def teardown_at_exit #:nodoc:
+      at_exit do
+        silence_stream(STDOUT) do
+          $browser.stop
+          Webrat.stop_app_server
+          Webrat.stop_selenium_server
+        end
+      end
+    end
+    
+    def adjust_if_regexp(text_or_regexp) #:nodoc:
+      if text_or_regexp.is_a?(Regexp)
+        "evalregex:#{text_or_regexp.inspect}"
+      else
+        text_or_regexp
+      end 
+    end
+    
+    def extend_selenium #:nodoc:
+      extensions_file = File.join(File.dirname(__FILE__), "selenium_extensions.js")
+      extenions_js = File.read(extensions_file)
+      selenium.get_eval(extenions_js)
+    end
+    
+    def define_location_strategies #:nodoc:
+      Dir[File.join(File.dirname(__FILE__), "location_strategy_javascript", "*.js")].sort.each do |file|
+        strategy_js = File.read(file)
+        strategy_name = File.basename(file, '.js')
+        selenium.add_location_strategy(strategy_name, strategy_js)
+      end
+    end
+  end
+end