rack-test 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1.0 / 2009-03-02
+
+* 1 major enhancement
+
+  * Birthday!

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008-2009 Bryan Helmkamp, Engine Yard Inc.
+
+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,57 @@
+= Rack::Test
+
+- http://gitrdoc.com/brynary/rack-test
+- http://github.com/brynary/rack-test
+
+== Description
+
+Rack::Test is a small, simple testing API for Rack apps. It can be used on its
+own or as a reusable starting point for Web frameworks and testing libraries
+to build on. Most of its initial functionality is an extraction of Merb 1.0's
+request helpers feature.
+
+== Features
+
+* Maintains a cookie jar across requests
+* Easily follow redirects when desired
+* Set request headers to be used by all subsequent requests
+* Small footprint. Approximately 200 LOC
+
+== Example
+
+  require "rack/test"
+  
+  class HomepageTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+    
+    def app
+      MyApp.new
+    end
+    
+    def test_redirect_logged_in_users_to_dashboard
+      authorize "bryan", "secret"
+      get "/"
+      follow_redirect!
+      
+      assert_equal "http://example.org/redirected", last_request.url
+      assert last_response.ok?
+    end
+    
+  end
+
+== Install
+
+To install the latest release as a gem:
+
+  sudo gem install rack-test
+
+== Authors
+
+- Maintained by {Bryan Helmkamp}[mailto:bryan@brynary.com]
+- Contributions from Simon Rozet and Pat Nakajima
+- Much of the original code was extracted from Merb 1.0's request helper
+
+== License
+
+Copyright (c) 2008-2009 Bryan Helmkamp, Engine Yard Inc.
+See MIT-LICENSE.txt in this directory.

data/Rakefile

@@ -0,0 +1,58 @@
+require "rubygems"
+require "rake/rdoctask"
+require "rake/gempackagetask"
+require "rake/clean"
+require "spec/rake/spectask"
+require File.expand_path("./lib/rack/test")
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+end
+
+desc "Run all specs in spec directory with RCov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+  t.rcov = true
+  t.rcov_opts = lambda do
+    IO.readlines(File.dirname(__FILE__) + "/spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+  end
+end
+
+desc "Run the specs"
+task :default => :spec
+
+spec = Gem::Specification.new do |s|
+  s.name         = "rack-test"
+  s.version      = Rack::Test::VERSION
+  s.author       = "Bryan Helmkamp"
+  s.email        = "bryan" + "@" + "brynary.com"
+  s.homepage     = "http://github.com/brynary/rack-test"
+  s.summary      = "Simple testing API built on Rack"
+  s.description  = s.summary
+  s.files        = %w[History.txt Rakefile README.rdoc] + Dir["lib/**/*"]
+  
+  # rdoc
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc MIT-LICENSE.txt)
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc "Delete generated RDoc"
+task :clobber_docs do
+  FileUtils.rm_rf("doc")
+end
+
+desc "Generate RDoc"
+task :docs => :clobber_docs do
+  system "hanna --title 'Rack::Test #{Rack::Test::VERSION} API Documentation'"
+end
+
+desc 'Install the package as a gem.'
+task :install => [:clean, :package] do
+  gem = Dir['pkg/*.gem'].first
+  sh "sudo gem install --local #{gem}"
+end
+

data/lib/rack/test.rb

@@ -0,0 +1,213 @@
+require "rubygems"
+
+unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__) + "/.."))
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/.."))
+end
+
+require "uri"
+require "rack"
+require "rack/test/cookie_jar"
+require "rack/test/utils"
+require "rack/test/methods"
+
+module Rack
+  module Test
+    
+    VERSION = "0.1.0"
+    
+    # The common base class for exceptions raised by Rack::Test
+    class Error < StandardError
+    end
+    
+    class Session
+      include Rack::Test::Utils
+
+      # Initialize a new session for the given Rack app
+      def initialize(app)
+        raise ArgumentError.new("app must respond_to?(:call)") unless app.respond_to?(:call)
+
+        @headers = {}
+        @app = app
+      end
+      
+      # Issue a GET request for the given URI with the given params and Rack
+      # environment. Stores the issues request object in #last_request and
+      # the app's response in #last_response. Yield #last_response to a block
+      # if given.
+      # 
+      # Example:
+      #   get "/"
+      def get(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "GET", :params => params))
+        process_request(uri, env, &block)
+      end
+      
+      # Issue a POST request for the given URI. See #get
+      # 
+      # Example:
+      #   post "/signup", "name" => "Bryan"
+      def post(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "POST", :params => params))
+        process_request(uri, env, &block)
+      end
+      
+      # Issue a PUT request for the given URI. See #get
+      # 
+      # Example:
+      #   put "/"
+      def put(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "PUT", :params => params))
+        process_request(uri, env, &block)
+      end
+      
+      # Issue a DELETE request for the given URI. See #get
+      # 
+      # Example:
+      #   delete "/"
+      def delete(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "DELETE", :params => params))
+        process_request(uri, env, &block)
+      end
+      
+      # Issue a HEAD request for the given URI. See #get
+      # 
+      # Example:
+      #   head "/"
+      def head(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "HEAD", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a request to the Rack app for the given URI and optional Rack
+      # environment. Stores the issues request object in #last_request and
+      # the app's response in #last_response. Yield #last_response to a block
+      # if given.
+      # 
+      # Example:
+      #   request "/"
+      def request(uri, env = {}, &block)
+        env = env_for(uri, env)
+        process_request(uri, env, &block)
+      end
+
+      # Set a header to be included on all subsequent requests through the
+      # session. Use a value of nil to remove a previously configured header.
+      # 
+      # Example:
+      #   header "User-Agent", "Firefox"
+      def header(name, value)
+        if value.nil?
+          @headers.delete(name)
+        else
+          @headers[name] = value
+        end
+      end
+      
+      # Set the username and password for HTTP Basic authorization, to be
+      # included in subsequent requests in the HTTP_AUTHORIZATION header.
+      # 
+      # Example:
+      #   authorize "bryan", "secret"
+      def authorize(username, password)
+        encoded_login = ["#{username}:#{password}"].pack("m*")
+        header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
+      end
+      
+      # Rack::Test will not follow any redirects automatically. This method
+      # will follow the redirect returned in the last response. If the last
+      # response was not a redirect, an error will be raised.
+      def follow_redirect!
+        unless last_response.redirect?
+          raise Error.new("Last response was not a redirect. Cannot follow_redirect!")
+        end
+        
+        get(last_response["Location"])
+      end
+
+      # Return the last request issued in the session. Raises an error if no
+      # requests have been sent yet.
+      def last_request
+        raise Error.new("No request yet. Request a page first.") unless @last_request
+
+        @last_request
+      end
+
+      # Return the last response received in the session. Raises an error if
+      # no requests have been sent yet.
+      def last_response
+        raise Error.new("No response yet. Request a page first.") unless @last_response
+
+        @last_response
+      end
+
+    private
+
+      
+      def env_for(path, env)
+        uri = URI.parse(path)
+        uri.host ||= "example.org"
+
+        env = default_env.merge(env)
+
+        if URI::HTTPS === uri
+          env.update("HTTPS" => "on")
+        end
+
+        if env[:xhr]
+          env["X-Requested-With"] = "XMLHttpRequest"
+        end
+        
+        if (env[:method] == "POST" || env["REQUEST_METHOD"] == "POST") && !env.has_key?(:input)
+          env["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+          env[:input] = params_to_string(env.delete(:params))
+        end
+
+        params = env[:params] || {}
+        params.update(parse_query(uri.query))
+        uri.query = requestify(params)
+
+        if env.has_key?(:cookie)
+          # Add the cookies explicitly set by the user
+          env["HTTP_COOKIE"] = cookie_jar.merge(uri, env.delete(:cookie)).for(uri)
+        else
+          env["HTTP_COOKIE"] = cookie_jar.for(uri)
+        end
+
+        Rack::MockRequest.env_for(uri.to_s, env)
+      end
+      
+      def cookie_jar
+        @cookie_jar || Rack::Test::CookieJar.new
+      end
+
+      def process_request(uri, env)
+        uri = URI.parse(uri)
+        uri.host ||= "example.org"
+
+        @last_request = Rack::Request.new(env)
+
+        status, headers, body = @app.call(@last_request.env)
+        @last_response = Rack::Response.new(body, status, headers)
+        @cookie_jar = cookie_jar.merge(uri, last_response.headers["Set-Cookie"])
+
+        yield @last_response if block_given?
+        
+        @last_response
+      end
+
+      def default_env
+        { "rack.test" => true, "REMOTE_ADDR" => "127.0.0.1" }.merge(@headers)
+      end
+
+      def params_to_string(params)
+        case params
+        when Hash then requestify(params)
+        when nil  then ""
+        else params
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rack/test/cookie_jar.rb

@@ -0,0 +1,121 @@
+module Rack
+  module Test
+
+    class Cookie
+      include Rack::Utils
+
+      # :api: private
+      attr_reader :name, :value
+
+      # :api: private
+      def initialize(raw, default_host)
+        # separate the name / value pair from the cookie options
+        @name_value_raw, options = raw.split(/[;,] */n, 2)
+
+        @name, @value = parse_query(@name_value_raw, ';').to_a.first
+        @options = parse_query(options, ';')
+
+        @options.delete_if { |k, v| !v || v.empty? }
+
+        @options["domain"] ||= default_host
+      end
+
+      # :api: private
+      def raw
+        @name_value_raw
+      end
+
+      # :api: private
+      def empty?
+        @value.nil? || @value.empty?
+      end
+
+      # :api: private
+      def domain
+        @options["domain"]
+      end
+
+      # :api: private
+      def path
+        @options["path"] || "/"
+      end
+
+      # :api: private
+      def expires
+        Time.parse(@options["expires"]) if @options["expires"]
+      end
+
+      # :api: private
+      def expired?
+        expires && expires < Time.now
+      end
+
+      # :api: private
+      def valid?(uri)
+        uri.host =~ Regexp.new("#{Regexp.escape(domain)}$") &&
+        uri.path =~ Regexp.new("^#{Regexp.escape(path)}")
+      end
+
+      # :api: private
+      def matches?(uri)
+        ! expired? && valid?(uri)
+      end
+
+      # :api: private
+      def <=>(other)
+        # Orders the cookies from least specific to most
+        [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
+      end
+
+    end
+
+    class CookieJar
+
+      # :api: private
+      def initialize(cookies = [])
+        @jar = cookies
+        @jar.sort!
+      end
+
+      def merge(uri, raw_cookies)
+        return self unless raw_cookies
+
+        # Initialize all the the received cookies
+        cookies = []
+        raw_cookies.each do |raw|
+          c = Cookie.new(raw, uri.host)
+          cookies << c if c.valid?(uri)
+        end
+
+        # Remove all the cookies that will be updated
+        new_jar = @jar.reject do |existing|
+          cookies.find do |c|
+            [c.name, c.domain, c.path] == [existing.name, existing.domain, existing.path]
+          end
+        end
+
+        new_jar.concat cookies
+
+        return self.class.new(new_jar)
+      end
+
+      # :api: private
+      def for(uri)
+        cookies = {}
+
+        # The cookies are sorted by most specific first. So, we loop through
+        # all the cookies in order and add it to a hash by cookie name if
+        # the cookie can be sent to the current URI. It's added to the hash
+        # so that when we are done, the cookies will be unique by name and
+        # we'll have grabbed the most specific to the URI.
+        @jar.each do |cookie|
+          cookies[cookie.name] = cookie.raw if cookie.matches?(uri)
+        end
+
+        cookies.values.join(';')
+      end
+
+    end
+
+  end
+end

data/lib/rack/test/methods.rb

@@ -0,0 +1,45 @@
+module Rack
+  module Test
+    
+    module Methods
+      
+      def self.delegate_to_rack_test_session(*meths)
+        meths.each do |meth|
+          self.class_eval <<-RUBY
+            def #{meth}(*args, &blk)
+              rack_test_session.#{meth}(*args, &blk)
+            end
+          RUBY
+        end
+      end
+      
+      def rack_test_session
+        @_rack_test_session ||= Rack::Test::Session.new(app)
+      end
+      
+      delegate_to_rack_test_session \
+        :request,
+        
+        # HTTP verbs
+        :get,
+        :post,
+        :put,
+        :delete,
+        :head,
+        
+        # Redirects
+        :follow_redirect!,
+        
+        # Header-related features
+        :header,
+        :authorize,
+
+        # Expose the last request and response
+        :last_response,
+        :last_request
+        
+        
+    end
+    
+  end
+end

data/lib/rack/test/utils.rb

@@ -0,0 +1,27 @@
+module Rack
+  module Test
+    
+    module Utils
+      include Rack::Utils
+      
+      def requestify(value, prefix = nil)
+        case value
+        when Array
+          value.map do |v|
+            requestify(v, "#{prefix}[]")
+          end.join("&")
+        when Hash
+          value.map do |k, v|
+            requestify(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          end.join("&")
+        else
+          "#{prefix}=#{escape(value)}"
+        end
+      end
+      
+      module_function :requestify
+      
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: rack-test
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Bryan Helmkamp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-04 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Simple testing API built on Rack
+email: bryan@brynary.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE.txt
+files: 
+- History.txt
+- Rakefile
+- README.rdoc
+- lib/rack
+- lib/rack/test
+- lib/rack/test/cookie_jar.rb
+- lib/rack/test/methods.rb
+- lib/rack/test/utils.rb
+- lib/rack/test.rb
+- MIT-LICENSE.txt
+has_rdoc: true
+homepage: http://github.com/brynary/rack-test
+post_install_message: 
+rdoc_options: []
+
+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.3.1
+signing_key: 
+specification_version: 2
+summary: Simple testing API built on Rack
+test_files: []
+