joebadmo-rack-test 0.6.1

data/lib/rack/test/methods.rb

@@ -0,0 +1,82 @@
+require "forwardable"
+
+module Rack
+  module Test
+
+    # This module serves as the primary integration point for using Rack::Test
+    # in a testing environment. It depends on an app method being defined in the
+    # same context, and provides the Rack::Test API methods (see Rack::Test::Session
+    # for their documentation).
+    #
+    # Example:
+    #
+    #   class HomepageTest < Test::Unit::TestCase
+    #     include Rack::Test::Methods
+    #
+    #     def app
+    #       MyApp.new
+    #     end
+    #   end
+    module Methods
+      extend Forwardable
+
+      def rack_mock_session(name = :default) # :nodoc:
+        return build_rack_mock_session unless name
+
+        @_rack_mock_sessions ||= {}
+        @_rack_mock_sessions[name] ||= build_rack_mock_session
+      end
+
+      def build_rack_mock_session # :nodoc:
+        Rack::MockSession.new(app)
+      end
+
+      def rack_test_session(name = :default) # :nodoc:
+        return build_rack_test_session(name) unless name
+
+        @_rack_test_sessions ||= {}
+        @_rack_test_sessions[name] ||= build_rack_test_session(name)
+      end
+
+      def build_rack_test_session(name) # :nodoc:
+        Rack::Test::Session.new(rack_mock_session(name))
+      end
+
+      def current_session # :nodoc:
+        rack_test_session(_current_session_names.last)
+      end
+
+      def with_session(name) # :nodoc:
+        _current_session_names.push(name)
+        yield rack_test_session(name)
+        _current_session_names.pop
+      end
+
+      def _current_session_names # :nodoc:
+        @_current_session_names ||= [:default]
+      end
+
+      METHODS = [
+        :request,
+        :get,
+        :post,
+        :put,
+        :patch,
+        :delete,
+        :options,
+        :head,
+        :follow_redirect!,
+        :header,
+        :set_cookie,
+        :clear_cookies,
+        :authorize,
+        :basic_authorize,
+        :digest_authorize,
+        :last_response,
+        :last_request
+      ]
+
+      def_delegators :current_session, *METHODS
+    end
+  end
+end

data/lib/rack/test/mock_digest_request.rb

@@ -0,0 +1,29 @@
+module Rack
+  module Test
+
+    class MockDigestRequest # :nodoc:
+
+      def initialize(params)
+        @params = params
+      end
+
+      def method_missing(sym)
+        if @params.has_key? k = sym.to_s
+          return @params[k]
+        end
+
+        super
+      end
+
+      def method
+        @params['method']
+      end
+
+      def response(password)
+        Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
+      end
+
+    end
+
+  end
+end

data/lib/rack/test/uploaded_file.rb

@@ -0,0 +1,50 @@
+require "tempfile"
+require "fileutils"
+
+module Rack
+  module Test
+
+    # Wraps a Tempfile with a content type. Including one or more UploadedFile's
+    # in the params causes Rack::Test to build and issue a multipart request.
+    #
+    # Example:
+    #   post "/photos", "file" => Rack::Test::UploadedFile.new("me.jpg", "image/jpeg")
+    class UploadedFile
+
+      # The filename, *not* including the path, of the "uploaded" file
+      attr_reader :original_filename
+
+      # The content type of the "uploaded" file
+      attr_accessor :content_type
+
+      def initialize(path, content_type = "text/plain", binary = false)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+
+        @content_type = content_type
+        @original_filename = ::File.basename(path)
+
+        @tempfile = Tempfile.new(@original_filename)
+        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+        @tempfile.binmode if binary
+
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+
+      def path
+        @tempfile.path
+      end
+
+      alias_method :local_path, :path
+
+      def method_missing(method_name, *args, &block) #:nodoc:
+        @tempfile.__send__(method_name, *args, &block)
+      end
+
+      def respond_to?(method_name, include_private = false) #:nodoc:
+        @tempfile.respond_to?(method_name, include_private) || super
+      end
+
+    end
+
+  end
+end

data/lib/rack/test/utils.rb

@@ -0,0 +1,136 @@
+module Rack
+  module Test
+
+    module Utils # :nodoc:
+      include Rack::Utils
+
+      def build_nested_query(value, prefix = nil)
+        case value
+        when Array
+          value.map do |v|
+            unless unescape(prefix) =~ /\[\]$/
+              prefix = "#{prefix}[]"
+            end
+            build_nested_query(v, "#{prefix}")
+          end.join("&")
+        when Hash
+          value.map do |k, v|
+            build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          end.join("&")
+        when NilClass
+          prefix.to_s
+        else
+          "#{prefix}=#{escape(value)}"
+        end
+      end
+
+      module_function :build_nested_query
+
+      def build_multipart(params, first = true)
+        if first
+          unless params.is_a?(Hash)
+            raise ArgumentError, "value must be a Hash"
+          end
+
+          multipart = false
+          query = lambda { |value|
+            case value
+            when Array
+              value.each(&query)
+            when Hash
+              value.values.each(&query)
+            when UploadedFile
+              multipart = true
+            end
+          }
+          params.values.each(&query)
+          return nil unless multipart
+        end
+
+        flattened_params = Hash.new
+
+        params.each do |key, value|
+          k = first ? key.to_s : "[#{key}]"
+
+          case value
+          when Array
+            value.map do |v|
+
+              if (v.is_a?(Hash))
+                build_multipart(v, false).each { |subkey, subvalue|
+                  flattened_params["#{k}[]#{subkey}"] = subvalue
+                }
+              else
+                flattened_params["#{k}[]"] = value
+              end
+
+            end
+          when Hash
+            build_multipart(value, false).each { |subkey, subvalue|
+              flattened_params[k + subkey] = subvalue
+            }
+          else
+            flattened_params[k] = value
+          end
+        end
+
+        if first
+          build_parts(flattened_params)
+        else
+          flattened_params
+        end
+      end
+
+      module_function :build_multipart
+
+    private
+      def build_parts(parameters)
+        parameters.map { |name, value|
+          if value.respond_to?(:original_filename)
+            build_file_part(name, value)
+
+          elsif value.is_a?(Array) and value.all? { |v| v.respond_to?(:original_filename) }
+            value.map do |v|
+              build_file_part(name, v)
+            end.join
+
+          else
+            primitive_part = build_primitive_part(name, value)
+            Rack::Test.encoding_aware_strings? ? primitive_part.force_encoding('BINARY') : primitive_part
+          end
+
+        }.join + "--#{MULTIPART_BOUNDARY}--\r"
+      end
+
+      def build_primitive_part(parameter_name, value)
+        unless value.is_a? Array
+          value = [value]
+        end
+        value.map do |v|
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{parameter_name}"\r
+\r
+#{v}\r
+EOF
+        end.join
+      end
+
+      def build_file_part(parameter_name, uploaded_file)
+        ::File.open(uploaded_file.path, "rb") do |physical_file|
+          physical_file.set_encoding(Encoding::BINARY) if physical_file.respond_to?(:set_encoding)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{parameter_name}"; filename="#{escape(uploaded_file.original_filename)}"\r
+Content-Type: #{uploaded_file.content_type}\r
+Content-Length: #{::File.stat(uploaded_file.path).size}\r
+\r
+#{physical_file.read}\r
+EOF
+        end
+      end
+
+    end
+
+  end
+end

data/rack-test.gemspec

@@ -0,0 +1,80 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = 'joebadmo-rack-test'
+  s.version = "0.6.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Bryan Helmkamp"]
+  s.date = %q{2011-07-27}
+  s.description = %q{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.}
+  s.email = %q{bryan@brynary.com}
+  s.extra_rdoc_files = [
+    "README.rdoc",
+    "MIT-LICENSE.txt"
+  ]
+  s.files = [
+    ".document",
+    ".gitignore",
+    "Gemfile",
+    "Gemfile.lock",
+    "History.txt",
+    "MIT-LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "Thorfile",
+    "lib/rack/mock_session.rb",
+    "lib/rack/test.rb",
+    "lib/rack/test/cookie_jar.rb",
+    "lib/rack/test/methods.rb",
+    "lib/rack/test/mock_digest_request.rb",
+    "lib/rack/test/uploaded_file.rb",
+    "lib/rack/test/utils.rb",
+    "rack-test.gemspec",
+    "spec/fixtures/bar.txt",
+    "spec/fixtures/config.ru",
+    "spec/fixtures/fake_app.rb",
+    "spec/fixtures/foo.txt",
+    "spec/rack/test/cookie_spec.rb",
+    "spec/rack/test/digest_auth_spec.rb",
+    "spec/rack/test/multipart_spec.rb",
+    "spec/rack/test/uploaded_file_spec.rb",
+    "spec/rack/test/utils_spec.rb",
+    "spec/rack/test_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/matchers/body.rb",
+    "spec/support/matchers/challenge.rb"
+  ]
+  s.homepage = %q{http://github.com/brynary/rack-test}
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rack-test}
+  s.rubygems_version = %q{1.6.1}
+  s.summary = %q{Simple testing API built on Rack}
+  s.test_files = [
+    "spec/fixtures/fake_app.rb",
+    "spec/rack/test/cookie_spec.rb",
+    "spec/rack/test/digest_auth_spec.rb",
+    "spec/rack/test/multipart_spec.rb",
+    "spec/rack/test/uploaded_file_spec.rb",
+    "spec/rack/test/utils_spec.rb",
+    "spec/rack/test_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/matchers/body.rb",
+    "spec/support/matchers/challenge.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 1.0"])
+    else
+      s.add_dependency(%q<rack>, [">= 1.0"])
+    end
+  else
+    s.add_dependency(%q<rack>, [">= 1.0"])
+  end
+end

data/spec/fixtures/bar.txt

@@ -0,0 +1 @@
+baz

data/spec/fixtures/config.ru

@@ -0,0 +1,3 @@
+require "fake_app"
+
+run Rack::Test::FakeApp

data/spec/fixtures/fake_app.rb

@@ -0,0 +1,143 @@
+require "rubygems"
+require "sinatra/base"
+
+module Rack
+  module Test
+
+    class FakeApp < Sinatra::Base
+      head "/" do
+        "meh"
+      end
+
+      options "/" do
+        [200, {}, ""]
+      end
+
+      get "/" do
+        "Hello, GET: #{params.inspect}"
+      end
+
+      get "/redirect" do
+        redirect "/redirected"
+      end
+
+      get "/redirected" do
+        "You've been redirected"
+      end
+
+      get "/void" do
+        [200, {}, ""]
+      end
+
+      get "/cookies/show" do
+        request.cookies.inspect
+      end
+
+      get "/COOKIES/show" do
+        request.cookies.inspect
+      end
+
+      get "/not-cookies/show" do
+        request.cookies.inspect
+      end
+
+      get "/cookies/set-secure" do
+        raise if params["value"].nil?
+
+        response.set_cookie("secure-cookie", :value => params["value"], :secure => true)
+        "Set"
+      end
+
+      get "/cookies/set-simple" do
+        raise if params["value"].nil?
+
+        response.set_cookie "simple", params["value"]
+        "Set"
+      end
+
+      post "/cookies/default-path" do
+        raise if params["value"].nil?
+
+        response.set_cookie "simple", params["value"]
+        "Set"
+      end
+
+      get "/cookies/default-path" do
+        response.cookies.inspect
+      end
+
+      get "/cookies/delete" do
+        response.delete_cookie "value"
+      end
+
+      get "/cookies/count" do
+        old_value = request.cookies["count"].to_i || 0
+        new_value = (old_value + 1).to_s
+
+        response.set_cookie("count", :value => new_value)
+        new_value
+      end
+
+      get "/cookies/set" do
+        raise if params["value"].nil?
+
+        response.set_cookie("value", {
+          :value => params["value"],
+          :path => "/cookies",
+          :expires => Time.now + 10
+        })
+        "Set"
+      end
+
+      get "/cookies/domain" do
+        old_value = request.cookies["count"].to_i || 0
+        new_value = (old_value + 1).to_s
+
+        response.set_cookie("count", :value => new_value, :domain => "localhost.com")
+        new_value
+      end
+
+      get "/cookies/subdomain" do
+        old_value = request.cookies["count"].to_i || 0
+        new_value = (old_value + 1).to_s
+
+        response.set_cookie("count", :value => new_value, :domain => ".example.org")
+        new_value
+      end
+
+      get "/cookies/set-uppercase" do
+        raise if params["value"].nil?
+
+        response.set_cookie("VALUE", {
+          :value => params["value"],
+          :path => "/cookies",
+          :expires => Time.now + 10
+        })
+        "Set"
+      end
+
+      get "/cookies/set-multiple" do
+        response.set_cookie("key1", :value => "value1")
+        response.set_cookie("key2", :value => "value2")
+        "Set"
+      end
+
+      post "/" do
+        "Hello, POST: #{params.inspect}"
+      end
+
+      put "/" do
+        "Hello, PUT: #{params.inspect}"
+      end
+
+      patch "/" do
+        "Hello, PUT: #{params.inspect}"
+      end
+
+      delete "/" do
+        "Hello, DELETE: #{params.inspect}"
+      end
+    end
+
+  end
+end