mkuklis-webrat 0.5.1

data/spec/integration/sinatra/modular_app.rb

@@ -0,0 +1,16 @@
+require "rubygems"
+require "sinatra/base"
+
+class MyModularApp < Sinatra::Default
+  get "/" do
+    "Hello World"
+  end
+
+  get "/redirect_absolute_url" do
+    redirect URI.join(request.url, "foo").to_s
+  end
+
+  get "/foo" do
+    "spam"
+  end
+end

data/spec/integration/sinatra/test/classic_app_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/test_helper"
+require File.dirname(__FILE__) + "/../classic_app"
+
+class MyClassicAppTest < Test::Unit::TestCase
+  def test_visits_pages
+    visit "/"
+    assert response_body.include?("visit")
+
+    click_link "there"
+    assert response_body.include?('<form method="post" action="/go">')
+  end
+
+  def test_submits_form
+    visit "/go"
+    fill_in "Name", :with => "World"
+    fill_in "Email", :with => "world@example.org"
+    click_button "Submit"
+
+    assert response_body.include?("Hello, World")
+    assert response_body.include?("Your email is: world@example.org")
+  end
+
+  def test_check_value_of_field
+    visit "/"
+    assert field_labeled("Prefilled").value, "text"
+  end
+
+  def test_follows_internal_redirects
+    visit "/internal_redirect"
+    assert response_body.include?("visit")
+  end
+
+  def test_does_not_follow_external_redirects
+    visit "/external_redirect"
+    assert response_code == 302
+  end
+end

data/spec/integration/sinatra/test/modular_app_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + "/test_helper"
+require File.dirname(__FILE__) + "/../modular_app"
+
+class MyModularAppTest < Test::Unit::TestCase
+  def app
+    MyModularApp
+  end
+
+  def test_it_works
+    visit "/"
+    assert_contain "Hello World"
+  end
+
+  def test_redirects
+    visit "/redirect_absolute_url"
+    assert_equal "spam", response_body
+  end
+end

data/spec/integration/sinatra/test/test_helper.rb

@@ -0,0 +1,17 @@
+require "rubygems"
+require "test/unit"
+# require "redgreen"
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../../../lib"
+require "webrat"
+
+Webrat.configure do |config|
+  config.mode = :sinatra
+end
+
+class Test::Unit::TestCase
+  include Webrat::Methods
+  include Webrat::Matchers
+
+  Webrat::Methods.delegate_to_session :response_code, :response_body
+end

data/spec/private/core/configuration_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Webrat::Configuration do
+
+  Spec::Matchers.define :open_error_files do
+    match do |config|
+      config.open_error_files?
+    end
+  end
+
+  it "should have a mode" do
+    Webrat.configuration.should respond_to(:mode)
+  end
+
+  it "should open error files by default" do
+    config = Webrat::Configuration.new
+    config.should open_error_files
+  end
+
+  it "should detect infinite redirects after 10" do
+    config = Webrat::Configuration.new
+    config.infinite_redirect_limit.should == 10
+  end
+
+  it "should be configurable with a block" do
+    Webrat.configure do |config|
+      config.open_error_files = false
+    end
+
+    config = Webrat.configuration
+    config.should_not open_error_files
+  end
+
+  it "should be configurable with multiple blocks" do
+    Webrat.configure do |config|
+      config.open_error_files = false
+    end
+
+    Webrat.configure do |config|
+      config.selenium_server_port = 1234
+    end
+
+    config = Webrat.configuration
+    config.should_not open_error_files
+    config.selenium_server_port.should == 1234
+  end
+
+  describe "Selenium" do
+    before :each do
+      @config = Webrat::Configuration.new
+    end
+
+    it "should use 'test' as the application environment by default" do
+      @config.application_environment.should == :test
+    end
+
+    it "should use 3001 as the application port by default" do
+      @config.application_port.should == 3001
+    end
+
+    it 'should default application address to localhost' do
+      @config.application_address.should == 'localhost'
+    end
+
+    it 'should default selenium server address to nil' do
+      @config.selenium_server_address.should be_nil
+    end
+
+    it 'should default selenium server port to 4444' do
+      @config.selenium_server_port.should == 4444
+    end
+
+    it 'should default selenium browser key to *firefox' do
+      @config.selenium_browser_key.should == '*firefox'
+    end
+
+    it 'should default selenium browser startup timeout to 5 seconds' do
+      @config.selenium_browser_startup_timeout.should == 5
+    end
+
+    it 'should allow overriding of the browser startup timeout' do
+      @config.selenium_browser_startup_timeout = 10
+      @config.selenium_browser_startup_timeout.should == 10
+    end
+  end
+
+end

data/spec/private/core/field_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+module Webrat
+  describe Field do
+    unless RUBY_PLATFORM =~ /java/
+      it "should have nice inspect output" do
+        html = <<-HTML
+          <html>
+          <input type='checkbox' checked='checked' />
+          </html>
+        HTML
+
+        element = Webrat::XML.document(html).css("input").first
+        checkbox = CheckboxField.new(nil, element)
+        checkbox.inspect.should =~ /#<Webrat::CheckboxField @element=<input type=['"]checkbox['"] checked(=['"]checked['"])?\/?>>/
+      end
+    end
+  end
+
+  describe CheckboxField do
+    it "should say it is checked if it is" do
+      html = <<-HTML
+        <html>
+        <input type='checkbox' checked='checked' />
+        </html>
+      HTML
+
+      element = Webrat::XML.document(html).css("input").first
+      checkbox = CheckboxField.new(nil, element)
+      checkbox.should be_checked
+    end
+
+    it "should say it is not checked if it is not" do
+      html = <<-HTML
+        <html>
+        <input type='checkbox' />
+        </html>
+      HTML
+
+      element = Webrat::XML.document(html).css("input").first
+      checkbox = CheckboxField.new(nil, element)
+      checkbox.should_not be_checked
+    end
+  end
+
+  describe RadioField do
+    it "should say it is checked if it is" do
+      html = <<-HTML
+        <html>
+        <input type='radio' checked='checked' />
+        </html>
+      HTML
+
+      element = Webrat::XML.document(html).css("input").first
+      radio_button = RadioField.new(nil, element)
+      radio_button.should be_checked
+    end
+
+    it "should say it is not checked if it is not" do
+      html = <<-HTML
+        <html><input type='radio' /></html>
+      HTML
+
+      element = Webrat::XML.document(html).css("input").first
+      radio_button = RadioField.new(nil, element)
+      radio_button.should_not be_checked
+    end
+  end
+
+  describe TextField do
+    it 'should not escape values in mechanize mode' do
+      Webrat.configuration.mode = :mechanize
+
+      html = <<-HTML
+        <html>
+          <input type="text" name="email" value="user@example.com" />
+        </html>
+      HTML
+
+      element    = Webrat::XML.document(html).css('input').first
+      text_field = TextField.new(nil, element)
+      text_field.to_param.should == { 'email' => 'user@example.com' }
+    end
+  end
+end

data/spec/private/core/link_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Webrat::Link do
+#  include Webrat::Link
+
+  before do
+    webrat_session = mock(Webrat::TestAdapter)
+    @link_text_with_nbsp = 'Link' + [0xA0].pack("U") + 'Text'
+  end
+
+  it "should pass through relative urls" do
+    link = Webrat::Link.new(webrat_session, {"href" => "/path"})
+    webrat_session.should_receive(:request_page).with("/path", :get, {})
+    link.click
+  end
+
+  it "shouldnt put base url onto " do
+    url = "https://www.example.com/path"
+    webrat_session.should_receive(:request_page).with(url, :get, {})
+    link = Webrat::Link.new(webrat_session, {"href" => url})
+    link.click
+  end
+
+end

data/spec/private/core/session_spec.rb

@@ -0,0 +1,200 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Webrat::Session do
+
+  it "should not have a doc_root" do
+    session = Webrat::Session.new
+    session.doc_root.should be_nil
+  end
+
+  it "should expose the current_dom" do
+    session = Webrat::Session.new
+
+    def session.response
+      Object.new
+    end
+
+    def session.response_body
+      "<html></html>"
+    end
+
+    session.should respond_to(:current_dom)
+  end
+
+  it "should provide a current_page for backwards compatibility" do
+    session = Webrat::Session.new
+    current_page = session.current_page
+    current_page.should_not be_nil
+    current_page.should respond_to(:url)
+  end
+
+  it "should allow custom headers to be set" do
+    session = Webrat::Session.new
+    session.header('Accept', 'application/xml')
+
+    session.instance_variable_get(:@custom_headers)['Accept'].should == 'application/xml'
+  end
+
+  it "should return a copy of the headers to be sent" do
+    session = Webrat::Session.new
+    session.instance_eval {
+      @default_headers = {'HTTP_X_FORWARDED_FOR' => '192.168.1.1'}
+      @custom_headers = {'Accept' => 'application/xml'}
+    }
+    session.headers.should == {'HTTP_X_FORWARDED_FOR' => '192.168.1.1', 'Accept' => 'application/xml'}
+  end
+
+  describe "#http_accept" do
+    before(:each) do
+      webrat_session = Webrat::Session.new
+    end
+
+    it "should set the Accept header with the string Mime type" do
+      webrat_session.http_accept('application/xml')
+      webrat_session.headers['Accept'].should == 'application/xml'
+    end
+
+    it "should set the Accept head with the string value of the symbol Mime type" do
+      webrat_session.http_accept(:xml)
+      webrat_session.headers['Accept'].should == 'application/xml'
+    end
+
+    it "should raise an error if a symbol Mime type is passed that does not exist" do
+      lambda { webrat_session.http_accept(:oogabooga) }.should raise_error(ArgumentError)
+    end
+
+    it "should recognize a couple of webrat-specific formats" do
+      webrat_session.http_accept(:multipart_form).should == "multipart/form-data"
+      webrat_session.http_accept(:url_encoded_form).should == "application/x-www-form-urlencoded"
+    end
+  end
+
+  describe "#request_page" do
+    before(:each) do
+      webrat_session = Webrat::Session.new
+    end
+
+    it "should raise an error if the request is not a success" do
+      webrat_session.stub!(:get)
+      webrat_session.stub!(:response_body => "Exception caught")
+      webrat_session.stub!(:response_code => 500)
+      webrat_session.stub!(:formatted_error => "application error")
+      webrat_session.stub!(:save_and_open_page)
+
+      lambda { webrat_session.request_page('some url', :get, {}) }.should raise_error(Webrat::PageLoadError)
+    end
+
+    it "should raise an error but not open if the request is not a success and config quashes save_and_open" do
+      Webrat.configure do |config|
+        config.open_error_files = false
+      end
+      webrat_session.stub!(:get)
+      webrat_session.stub!(:response_body => "Exception caught")
+      webrat_session.stub!(:response_code => 500)
+      webrat_session.stub!(:formatted_error => "application error")
+      webrat_session.should_not_receive(:save_and_open_page)
+
+      lambda { webrat_session.request_page('some url', :get, {}) }.should raise_error(Webrat::PageLoadError)
+    end
+
+    it "should now follow external redirects" do
+      webrat_session.should_receive(:internal_redirect?).and_return(false)
+
+      webrat_session.request_page("/oldurl", :get, {})
+
+      webrat_session.current_url.should == "/oldurl"
+    end
+  end
+
+  describe "#redirect?" do
+    before(:each) do
+      webrat_session = Webrat::Session.new
+    end
+
+    it "should return true if the last response was a redirect and Fixnum#/ returns a Rational" do
+      # This happens if the ruby-units gem has been required
+      Fixnum.class_eval do
+        alias_method :original_divide, "/".to_sym
+
+        def /(other)
+          Rational(self, other)
+        end
+      end
+
+      webrat_session.stub!(:response_code => 301)
+      webrat_session.redirect?.should be_true
+
+      Fixnum.class_eval do
+        alias_method "/".to_sym, :original_divide
+      end
+    end
+
+    it "should return true if the last response was a redirect" do
+      webrat_session.stub!(:response_code => 301)
+      webrat_session.redirect?.should be_true
+    end
+
+    it "should return false if the last response wasn't a redirect" do
+      webrat_session.stub!(:response_code => 200)
+      webrat_session.redirect?.should be_false
+    end
+  end
+
+  describe "#internal_redirect?" do
+    before(:each) do
+      webrat_session = Webrat::Session.new
+    end
+
+    it "should return true if the last response was a redirect and the host of the current_url matches that of the response location" do
+      webrat_session.stub!(:redirect?         => true)
+      webrat_session.stub!(:current_url       => "http://example.com")
+      webrat_session.stub!(:response_location => "http://example.com")
+      webrat_session.internal_redirect?.should be_true
+    end
+
+    it "should return true if the last response was a redirect and the hosts are the same but the subdomains are different" do
+      webrat_session.stub!(:redirect?         => true)
+      webrat_session.stub!(:current_url       => "http://example.com")
+      webrat_session.stub!(:response_location => "http://myName.example.com")
+      webrat_session.internal_redirect?.should be_true
+    end
+
+    it "should return false if the last response was not a redirect" do
+      webrat_session.stub!(:redirect? => false)
+      webrat_session.internal_redirect?.should be_false
+    end
+
+    it "should return false if the last response was a redirect but the host of the current_url doesn't matches that of the response location" do
+      webrat_session.stub!(:redirect?         => true)
+      webrat_session.stub!(:current_url       => "http://example.com")
+      webrat_session.stub!(:response_location => "http://google.com")
+      webrat_session.internal_redirect?.should be_false
+    end
+
+    it "should return false if the last response was a redirect but the host of the current_url doesn't matches that of the response location, but they have the same subdomain" do
+      webrat_session.stub!(:redirect?         => true)
+      webrat_session.stub!(:current_url       => "http://login.example.com")
+      webrat_session.stub!(:response_location => "http://login.google.com")
+      webrat_session.internal_redirect?.should be_false
+    end
+  end
+
+  describe "#redirected_to" do
+    before(:each) do
+      webrat_session = Webrat::Session.new
+    end
+
+    it "should return nil if not redirected" do
+      webrat_session.stub!(:redirect? => false)
+      webrat_session.redirected_to.should be_nil
+    end
+
+    it "should return the response_location if redirected" do
+      webrat_session.stub!(:redirect?         => true)
+      webrat_session.stub!(:response_location => "http://www.example.com")
+      webrat_session.redirected_to.should == "http://www.example.com"
+    end
+
+  end
+
+end

data/spec/private/mechanize/mechanize_adapter_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Webrat::MechanizeAdapter do
+  before :each do
+    Webrat.configuration.mode = :mechanize
+  end
+
+  before(:each) do
+    @mech = Webrat::MechanizeAdapter.new
+  end
+
+  describe "post" do
+    def url
+      'http://test.host/users'
+    end
+
+    def data
+      {:user => {:first_name => 'Nancy', :last_name => 'Callahan'}}
+    end
+
+    def flattened_data
+      {'user[first_name]' => 'Nancy', 'user[last_name]' => 'Callahan'}
+    end
+
+    it "should flatten model post data" do
+      mechanize = mock(:mechanize)
+      WWW::Mechanize.stub!(:new => mechanize)
+      mechanize.should_receive(:post).with(url, flattened_data)
+      Webrat::MechanizeAdapter.new.post(url, data)
+    end
+  end
+
+  describe "#absolute_url" do
+    before(:each) do
+      @session = Webrat::MechanizeAdapter.new
+      @session.stub!(:current_url).and_return(absolute_url)
+    end
+
+    def absolute_url
+      'http://test.host/users/fred/cabbages'
+    end
+
+    def rooted_url
+      '/users/fred/cabbages'
+    end
+
+    def relative_url
+      '../../wilma'
+    end
+
+    it "should return unmodified url if prefixed with scheme" do
+      @session.absolute_url(absolute_url).should == absolute_url
+    end
+
+    it "should prefix scheme and hostname if url begins with /" do
+      @session.absolute_url(rooted_url).should == absolute_url
+    end
+
+    it "should resolve sibling URLs relative to current path" do
+      @session.absolute_url(relative_url).should == 'http://test.host/users/wilma'
+    end
+
+    it "should cope with sibling URLs from root of site" do
+      @session.stub!(:current_url).and_return('http://test.host')
+      @session.absolute_url(relative_url).should == 'http://test.host/wilma'
+    end
+
+    it "should cope with https" do
+      @session.stub!(:current_url).and_return('https://test.host')
+      @session.absolute_url(relative_url).should == 'https://test.host/wilma'
+    end
+  end
+end

data/spec/private/nokogiri_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+# if defined?(Nokogiri::XML) && Webrat.configuration.parse_with_nokogiri?
+  describe "Nokogiri Extension" do
+    include Webrat::Matchers
+
+    def fail
+      raise_error(Spec::Expectations::ExpectationNotMetError)
+    end
+
+    before(:each) do
+      @text_and_password = <<-HTML
+        <div>
+          <input type="text"/>
+          <input type="password"/>
+          <span type="text"/>
+        </div>
+      HTML
+
+      @text_only = <<-HTML
+        <div>
+          <input type="text" disabled="disabled" />
+        </div>
+      HTML
+
+      @password_only = <<-HTML
+        <div>
+          <input type="password"/>
+        <div>
+      HTML
+    end
+
+    describe ":text" do
+      it "passes have_selector(:text) if a node with type=text exists" do
+        @text_and_password.should have_selector(":text")
+      end
+
+      it "passes not have_selector(:text) if no node with text=text exists" do
+        @password_only.should_not have_selector(":text")
+      end
+
+      it "fails have_selector(:text) if no node with type=text exists" do
+        lambda { @password_only.should have_selector(":text") }.should fail
+      end
+
+      it "fails not have_selector(:text) if a node with type=text exists" do
+        lambda { @text_only.should_not have_selector(":text") }.should fail
+      end
+
+      it "works together with other selectors" do
+        @text_and_password.should have_selector("input:text[type*='te']")
+      end
+    end
+
+    describe ":password" do
+      it "passes have_selector(:password) if a node with type=password exists" do
+        @text_and_password.should have_selector(":password")
+      end
+
+      it "passes not have_selector(:text) if no node with text=text exists" do
+        @text_only.should_not have_selector(":password")
+      end
+
+      it "fails have_selector(:password) if no node with type=password exists" do
+        lambda { @text_only.should have_selector(":password") }.should fail
+      end
+
+      it "fails not have_selector(:password) if a node with type=password exists" do
+        lambda { @password_only.should_not have_selector(":password") }.should fail
+      end
+
+      it "works together with other selectors" do
+        @text_and_password.should have_selector("input:password[type*='pa']")
+      end
+    end
+  end
+# end