raldred-webrat 0.4.4.2

data/lib/webrat/selenium/silence_stream.rb

@@ -0,0 +1,18 @@
+module Webrat
+  module Selenium
+    module SilenceStream
+      # active_support already defines silence_stream, no need to do that again if it's already present.
+      # http://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/kernel/reporting.rb
+      unless Kernel.respond_to?(:silence_stream)
+        def silence_stream(stream)
+          old_stream = stream.dup
+          stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+          stream.sync = true
+          yield
+        ensure
+          stream.reopen(old_stream)
+        end
+      end      
+    end
+  end
+end

data/lib/webrat/selenium/sinatra_application_server.rb

@@ -0,0 +1,35 @@
+module Webrat
+  module Selenium
+
+    class SinatraApplicationServer < ApplicationServer
+
+      def start
+        fork do
+          File.open('rack.pid', 'w') { |fp| fp.write Process.pid }
+          exec 'rackup', File.expand_path(Dir.pwd + '/config.ru'), '-p', Webrat.configuration.application_port.to_s
+        end
+      end
+
+      def stop
+        silence_stream(STDOUT) do
+          pid = File.read(pid_file)
+          system("kill -9 #{pid}")
+          FileUtils.rm_f pid_file
+        end
+      end
+
+      def fail
+        $stderr.puts
+        $stderr.puts
+        $stderr.puts "==> Failed to boot the Sinatra application server... exiting!"
+        exit
+      end
+
+      def pid_file
+        prepare_pid_file(Dir.pwd, 'rack.pid')
+      end
+
+    end
+
+  end
+end

data/lib/webrat/sinatra.rb

@@ -0,0 +1,44 @@
+require "webrat/rack"
+require "sinatra/test"
+
+module Webrat
+  class SinatraSession < RackSession
+    include Sinatra::Test
+
+    attr_reader :request, :response
+
+    def initialize(context = nil)
+      super(context)
+
+      app = context.respond_to?(:app) ? context.app : Sinatra::Application
+      @browser = Sinatra::TestHarness.new(app)
+    end
+
+    %w(get head post put delete).each do |verb|
+      class_eval <<-RUBY
+        def #{verb}(path, data, headers = {})
+          params = data.inject({}) do |data, (key,value)|
+            data[key] = Rack::Utils.unescape(value)
+            data
+          end
+          headers["HTTP_HOST"] = "www.example.com"
+          @browser.#{verb}(path, params, headers)
+        end
+      RUBY
+    end
+
+    def response_body
+      @browser.body
+    end
+
+    def response_code
+      @browser.status
+    end
+
+    private
+
+      def response
+        @browser.response
+      end
+  end
+end

data/spec/fakes/test_session.rb

@@ -0,0 +1,34 @@
+module Webrat #:nodoc:
+  def self.session_class #:nodoc:
+    TestSession
+  end
+
+  class TestSession < Session #:nodoc:
+    attr_accessor :response_body
+    attr_writer :response_code
+
+    def doc_root
+      File.expand_path(File.join(".", "public"))
+    end
+
+    def response
+      @response ||= Object.new
+    end
+
+    def response_code
+      @response_code || 200
+    end
+
+    def get(url, data, headers = nil)
+    end
+
+    def post(url, data, headers = nil)
+    end
+
+    def put(url, data, headers = nil)
+    end
+
+    def delete(url, data, headers = nil)
+    end
+  end
+end

data/spec/integration/merb/app/controllers/application.rb

@@ -0,0 +1,2 @@
+class Application < Merb::Controller
+end

data/spec/integration/merb/app/controllers/exceptions.rb

@@ -0,0 +1,13 @@
+class Exceptions < Merb::Controller
+
+  # handle NotFound exceptions (404)
+  def not_found
+    render :format => :html
+  end
+
+  # handle NotAcceptable exceptions (406)
+  def not_acceptable
+    render :format => :html
+  end
+
+end

data/spec/integration/merb/app/controllers/testing.rb

@@ -0,0 +1,18 @@
+class Testing < Application
+
+  def show_form
+    render
+  end
+
+  def submit_form
+  end
+
+  def internal_redirect
+    redirect "/"
+  end
+
+  def external_redirect
+    redirect "http://google.com"
+  end
+
+end

data/spec/integration/merb/config/environments/development.rb

@@ -0,0 +1,15 @@
+Merb.logger.info("Loaded DEVELOPMENT Environment...")
+Merb::Config.use { |c|
+  c[:exception_details] = true
+  c[:reload_templates] = true
+  c[:reload_classes] = true
+  c[:reload_time] = 0.5
+  c[:ignore_tampered_cookies] = true
+  c[:log_auto_flush ] = true
+  c[:log_level] = :debug
+
+  c[:log_stream] = STDOUT
+  c[:log_file]   = nil
+  # Or redirect logging into a file:
+  # c[:log_file]  = Merb.root / "log" / "development.log"
+}

data/spec/integration/merb/config/environments/rake.rb

@@ -0,0 +1,11 @@
+Merb.logger.info("Loaded RAKE Environment...")
+Merb::Config.use { |c|
+  c[:exception_details] = true
+  c[:reload_classes]  = false
+  c[:log_auto_flush ] = true
+
+  c[:log_stream] = STDOUT
+  c[:log_file]   = nil
+  # Or redirect logging into a file:
+  # c[:log_file]  = Merb.root / "log" / "development.log"
+}

data/spec/integration/merb/config/environments/test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../../../../../lib/webrat"
+
+Merb.logger.info("Loaded TEST Environment...")
+Merb::Config.use { |c|
+  c[:testing]           = true
+  c[:exception_details] = true
+  c[:log_auto_flush ]   = true
+  # log less in testing environment
+  c[:log_level]         = :error
+
+  #c[:log_file]  = Merb.root / "log" / "test.log"
+  # or redirect logger using IO handle
+  c[:log_stream] = STDOUT
+}

data/spec/integration/merb/config/init.rb

@@ -0,0 +1,25 @@
+# Go to http://wiki.merbivore.com/pages/init-rb
+
+# Specify a specific version of a dependency
+# dependency "RedCloth", "> 3.0"
+
+#  use_orm :none
+use_test :rspec
+use_template_engine :erb
+
+Merb::Config.use do |c|
+  c[:use_mutex] = false
+  c[:session_store] = 'cookie'  # can also be 'memory', 'memcache', 'container', 'datamapper
+
+  # cookie session store configuration
+  c[:session_secret_key]  = 'adb9ea7a0e94b5513503f58623a393c5efe18851'  # required for cookie session store
+  c[:session_id_key] = '_merb_session_id' # cookie session id key, defaults to "_session_id"
+end
+
+Merb::BootLoader.before_app_loads do
+  # This will get executed after dependencies have been loaded but before your app's classes have loaded.
+end
+
+Merb::BootLoader.after_app_loads do
+  # This will get executed after your app's classes have been loaded.
+end

data/spec/integration/merb/config/rack.rb

@@ -0,0 +1,11 @@
+# use PathPrefix Middleware if :path_prefix is set in Merb::Config
+if prefix = ::Merb::Config[:path_prefix]
+  use Merb::Rack::PathPrefix, prefix
+end
+
+# comment this out if you are running merb behind a load balancer
+# that serves static files
+use Merb::Rack::Static, Merb.dir_for(:public)
+
+# this is our main merb application
+run Merb::Rack::Application.new

data/spec/integration/merb/config/router.rb

@@ -0,0 +1,33 @@
+# Merb::Router is the request routing mapper for the merb framework.
+#
+# You can route a specific URL to a controller / action pair:
+#
+#   match("/contact").
+#     to(:controller => "info", :action => "contact")
+#
+# You can define placeholder parts of the url with the :symbol notation. These
+# placeholders will be available in the params hash of your controllers. For example:
+#
+#   match("/books/:book_id/:action").
+#     to(:controller => "books")
+#
+# Or, use placeholders in the "to" results for more complicated routing, e.g.:
+#
+#   match("/admin/:module/:controller/:action/:id").
+#     to(:controller => ":module/:controller")
+#
+# You can specify conditions on the placeholder by passing a hash as the second
+# argument of "match"
+#
+#   match("/registration/:course_name", :course_name => /^[a-z]{3,5}-\d{5}$/).
+#     to(:controller => "registration")
+#
+# You can also use regular expressions, deferred routes, and many other options.
+# See merb/specs/merb/router.rb for a fairly complete usage sample.
+
+Merb.logger.info("Compiling routes...")
+Merb::Router.prepare do
+  match("/").to(:controller => "testing", :action => "show_form")
+  match("/internal_redirect").to(:controller => "testing", :action => "internal_redirect")
+  match("/external_redirect").to(:controller => "testing", :action => "external_redirect")
+end

data/spec/integration/merb/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require "rubygems"
+
+# Add the local gems dir if found within the app root; any dependencies loaded
+# hereafter will try to load from the local gems before loading system gems.
+if (local_gem_dir = File.join(File.dirname(__FILE__), '..', 'gems')) && $BUNDLE.nil?
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(local_gem_dir)
+end
+
+require "merb-core"
+require "spec" # Satisfies Autotest and anyone else not using the Rake tasks
+
+# this loads all plugins required in your init file so don't add them
+# here again, Merb will do it for you
+Merb.start_environment(:testing => true, :adapter => 'runner', :environment => ENV['MERB_ENV'] || 'test')
+
+Spec::Runner.configure do |config|
+  config.include(Merb::Test::ViewHelper)
+  config.include(Merb::Test::RouteHelper)
+  config.include(Merb::Test::ControllerHelper)
+end
+
+Webrat.configure do |config|
+  config.mode = :merb
+end

data/spec/integration/merb/spec/webrat_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Webrat" do
+  it "should visit pages" do
+    response = visit "/"
+    response.should contain("Webrat Form")
+  end
+
+  it "should submit forms" do
+    visit "/"
+    fill_in "Text field", :with => "Hello"
+    check "TOS"
+    select "January"
+    click_button "Test"
+  end
+
+  it "should follow internal redirects" do
+    response = visit "/internal_redirect"
+    response.status.should == 200
+    response.should contain("Webrat Form")
+  end
+
+  it "should check the value of a field" do
+    visit "/"
+    field_labeled("Prefilled").value.should == "text"
+  end
+
+  it "should not follow external redirects" do
+    response = visit "/external_redirect"
+    response.status.should == 302
+  end
+end

data/spec/integration/merb/tasks/merb.thor/app_script.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+# This was added by Merb's bundler
+
+require "rubygems"
+require File.join(File.dirname(__FILE__), "common")
+
+gems_dir = File.join(File.dirname(__FILE__), '..', 'gems')
+
+if File.directory?(gems_dir)
+  $BUNDLE = true
+  Gem.clear_paths
+  Gem.path.replace([File.expand_path(gems_dir)])
+  ENV["PATH"] = "#{File.dirname(__FILE__)}:#{ENV["PATH"]}"
+
+  gem_file = File.join(gems_dir, "specifications", "<%= spec.name %>-*.gemspec")
+
+  if local_gem = Dir[gem_file].last
+    version = File.basename(local_gem)[/-([\.\d]+)\.gemspec$/, 1]
+  end
+end
+
+version ||= "<%= Gem::Requirement.default %>"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '<%= @spec.name %>', version
+load '<%= bin_file_name %>'

data/spec/integration/merb/tasks/merb.thor/common.rb

@@ -0,0 +1,64 @@
+# This was added via Merb's bundler
+
+require "rubygems"
+require "rubygems/source_index"
+
+module Gem
+  BUNDLED_SPECS = File.join(Dir.pwd, "gems", "specifications")
+  MAIN_INDEX = Gem::SourceIndex.from_gems_in(BUNDLED_SPECS)
+  FALLBACK_INDEX = Gem::SourceIndex.from_installed_gems
+
+  def self.source_index
+    MultiSourceIndex.new
+  end
+
+  def self.searcher
+    MultiPathSearcher.new
+  end
+
+  class ArbitrarySearcher < GemPathSearcher
+    def initialize(source_index)
+      @source_index = source_index
+      super()
+    end
+
+    def init_gemspecs
+      @source_index.map { |_, spec| spec }.sort { |a,b|
+        (a.name <=> b.name).nonzero? || (b.version <=> a.version)
+      }
+    end
+  end
+
+  class MultiPathSearcher
+    def initialize
+      @main_searcher = ArbitrarySearcher.new(MAIN_INDEX)
+      @fallback_searcher = ArbitrarySearcher.new(FALLBACK_INDEX)
+    end
+
+    def find(path)
+      try = @main_searcher.find(path)
+      return try if try
+      @fallback_searcher.find(path)
+    end
+
+    def find_all(path)
+      try = @main_searcher.find_all(path)
+      return try unless try.empty?
+      @fallback_searcher.find_all(path)
+    end
+  end
+
+  class MultiSourceIndex
+    def search(*args)
+      try = MAIN_INDEX.search(*args)
+      return try unless try.empty?
+      FALLBACK_INDEX.search(*args)
+    end
+
+    def find_name(*args)
+      try = MAIN_INDEX.find_name(*args)
+      return try unless try.empty?
+      FALLBACK_INDEX.find_name(*args)
+    end
+  end
+end