eol_rackbox 1.1.7

data/lib/rackbox/matchers.rb

@@ -0,0 +1,30 @@
+class RackBox
+
+  # Custom RSpec matchers
+  module Matchers
+
+    def self.included base
+      
+      # this should really just be matcher(:foo){ ... }
+      # but there's a bit of other meta logic to deal with here
+      Object.send :remove_const, :RedirectTo if defined? RedirectTo
+      undef redirect_to if defined? redirect_to
+
+      # the actual matcher logic
+      matcher(:redirect_to, base) do |response, url|
+        return false unless response['Location']
+        if url =~ /^\//
+          # looking for a relative match, eg. should redirect_to('/login')
+          relative_location = response['Location'].sub(/^https?:\/\//,'').sub(/^[^\/]*/,'')
+          # ^ there's probably a helper on Rack or CGI to do this
+          relative_location.downcase == url.downcase
+        else
+          response['Location'].downcase == url.downcase
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/rackbox/rack/content_length_fix.rb

@@ -0,0 +1,19 @@
+# An evil fix
+#
+# The actual fix 
+# has been pulled upstream into Rack
+# but hasn't made it into the Rack gem yet, so we need this fix until the new gem is released
+#
+class Rack::MockRequest
+  class << self
+
+    alias env_for_without_content_length_fix env_for
+    def env_for_with_content_length_fix uri = '', opts = {}
+      env = env_for_without_content_length_fix uri, opts
+      env['CONTENT_LENGTH'] ||= env['rack.input'].length
+      env
+    end
+    alias env_for env_for_with_content_length_fix
+
+  end
+end

data/lib/rackbox/rack/extensions_for_rspec.rb

@@ -0,0 +1,33 @@
+# some more Rack extensions to help when testing
+class Rack::MockResponse
+
+  # TODO checkout Rack::Response::Helpers which implements many of these!
+
+  # these methods help with RSpec specs so we can ask things like:
+  #
+  #   request('/').should be_successful
+  #   request('/').should be_redirect
+  #   request('/').should be_error
+  #
+
+  def success?
+    self.status.to_s.start_with?'2' # 200 status codes are successful
+  end
+
+  def redirect?
+    self.status.to_s.start_with?'3' # 300 status codes are redirects
+  end
+
+  def client_error?
+    self.status.to_s.start_with?'4' # 400 status codes are client errors
+  end
+
+  def server_error?
+    self.status.to_s.start_with?'5' # 500 status codes are server errors
+  end
+
+  def error?
+    self.status.to_s.start_with?('4') || self.status.to_s.start_with?('5') # 400 & 500 status codes are errors
+  end
+
+end

data/lib/rackbox/rack/sticky_sessions.rb

@@ -0,0 +1,54 @@
+#
+# little extension to Rack::MockRequest to track cookies
+#
+class Rack::MockRequest
+  # cookies is a hash of persistent cookies (by domain)
+  # that let you test cookies for your app
+  #
+  # cookies = {
+  #    'example.org' => {
+  #       'cookie-name' => 'cookie-value',
+  #       'chunky' => 'bacon'
+  #    }
+  # }
+  attr_accessor :cookies
+
+  # shortcut to get cookies for a particular domain
+  def cookies_for domain
+    @cookies ||= {}
+    @cookies[ domain ]
+  end
+
+  # oh geez ... it looks like i basically copy/pasted this.  there's gotta be a way to do this that's 
+  #             more resilient to Rack changes to this method.  i don't like overriding the whole method!
+  #
+  def request method = "GET", uri = "", opts = { }
+
+    env = self.class.env_for(uri, opts.merge(:method => method))
+    
+    unless @cookies.nil? or @cookies.empty? or @cookies[env['SERVER_NAME']].nil? or @cookies[env['SERVER_NAME']].empty?
+      env['HTTP_COOKIE'] = @cookies[env['SERVER_NAME']].map{ |k,v| "#{ k }=#{ v }" }.join('; ')
+    end
+
+    if opts[:lint]
+      app = Rack::Lint.new(@app)
+    else
+      app = @app
+    end 
+
+    errors = env["rack.errors"]
+    response = Rack::MockResponse.new(*(app.call(env) + [errors]))
+    
+    if response.original_headers['Set-Cookie']
+      @cookies ||= {}
+      @cookies[ env['SERVER_NAME'] ] ||= {}
+      response.headers['Set-Cookie'].map{ |str| /(.*); path/.match(str)[1] }.each do |cookie|
+        name, value = cookie.split('=').first, cookie.split('=')[1]
+        @cookies[ env['SERVER_NAME'] ][ name ] = value
+      end
+    end
+
+    response
+  end
+
+end

data/lib/rackbox/rackbox.rb

@@ -0,0 +1,186 @@
+
+# To add blackbox testing to a Rails app,
+# in your spec_helper.rb
+#
+#   require 'rackbox'
+#
+#   Spec::Runner.configure do |config|
+#     config.use_blackbox = true
+#   end
+#
+class RackBox
+
+  # i am an rdoc comment on RackBox's eigenclass
+  class << self
+
+    # to turn on some verbosity / logging, set:
+    #   RackBox.verbose = true
+    attr_accessor :verbose
+
+    # A port of Merb's request() method, used in tests
+    #
+    # At the moment, we're using #req instead because #request conflicts 
+    # with an existing RSpec-Rails method
+    #
+    # Usage:
+    #   
+    #   req '/'
+    #   req login_path
+    #   req url_for(:controller => 'login')
+    #
+    #   req '/', :method => :post, :params => { 'chunky' => 'bacon' }
+    #
+    #   req '/', :data => "some XML data to POST"
+    #
+    # TODO take any additional options and pass them along to the environment, so we can say 
+    #      req '/', :user_agent => 'some custom user agent'
+    #
+    def req app_or_request, url = nil, options = {}
+      puts "RackBox#request url:#{ url.inspect }, options:#{ options.inspect }" if RackBox.verbose
+
+      # handle RackBox.request '/foo'
+      if app_or_request.is_a?(String) && ( url.nil? || url.is_a?(Hash) )
+        options        = url || {}
+        url            = app_or_request
+        app_or_request = RackBox.app
+      end
+
+      # need to find the request or app
+      mock_request = nil
+      if app_or_request.is_a? Rack::MockRequest
+        mock_request = app_or_request
+      elsif app_or_request.nil?
+        if RackBox.app.nil?
+          raise "Not sure howto to execute a request against app or request: #{ app_or_request.inspect }"
+        else
+          mock_request = Rack::MockRequest.new(RackBox.app) # default to RackBox.app if nil
+        end
+      elsif app_or_request.respond_to? :call
+        mock_request = Rack::MockRequest.new(app_or_request)
+      else
+        raise "Not sure howto to execute a request against app or request: #{ app_or_request.inspect }"
+      end
+
+      options[:method] ||= ( options[:params] || options[:data] ) ? :post : :get # if params, default to POST, else default to GET
+      options[:params] ||= { }
+
+      if options[:data]
+        # input should be the data we're likely POSTing ... this overrides any params
+        input = options[:data]
+      else
+        # input should be params, if any
+        input = RackBox.build_query options[:params]
+      end
+
+      # add HTTP BASIC AUTH support
+      #
+      # TODO: DRY this up!
+      #
+      if options[:auth]
+        options[:http_basic_authentication] = options[:auth]
+        options.delete :auth
+      end
+      if options[:basic_auth]
+        options[:http_basic_authentication] = options[:basic_auth]
+        options.delete :basic_auth
+      end
+      if options[:http_basic_authentication]
+        username, password = options[:http_basic_authentication]
+        options.delete :http_basic_authentication
+        require 'base64'
+        # for some reason, nase64 encoding adds a \n
+        encoded_username_and_password = Base64.encode64("#{ username }:#{ password }").sub(/\n$/, '')
+        options['HTTP_AUTHORIZATION'] = "Basic #{ encoded_username_and_password }"
+      end
+
+      headers = options.dup
+      headers.delete :data   if headers[:data]
+      headers.delete :params if headers[:params]
+      headers.delete :method if headers[:method]
+
+      # merge input
+      headers[:input] = input
+      
+      puts "  requesting #{ options[:method].to_s.upcase } #{ url.inspect } #{ headers.inspect }" if RackBox.verbose
+      mock_request.send options[:method], url, headers
+    end
+
+    alias request req unless defined? request
+
+    # the Rack appliction to do 'Black Box' testing against
+    #
+    # To set, in your spec_helper.rb or someplace:
+    #   RackBox.app = Rack::Adapter::Rails.new :root => '/root/directory/of/rails/app', :environment => 'test'
+    #
+    # If not explicitly set, uses RAILS_ROOT (if defined?) and RAILS_ENV (if defined?)
+    attr_accessor :app
+
+    def app options = { }
+      unless @app and @app.respond_to?:call
+
+        options = {
+          :silent => false
+        }.merge(options)
+
+        if File.file? 'config.ru'
+          @app = Rack::Builder.new { eval(File.read('config.ru')) }
+        
+        elsif defined?RAILS_ENV and defined?RAILS_ROOT
+          unless defined?Rack::Adapter::Rails
+            # TODO this is no longer true ... right?  does rails < 2.3 work without Thin
+            puts "You need the Rack::Adapter::Rails to run Rails apps with RackBox." + 
+                 " Try: sudo gem install thin" unless options[:silent]
+          else
+            @app = Rack::Adapter::Rails.new :root => RAILS_ROOT, :environment => RAILS_ENV
+          end
+
+        elsif File.file?('config/routes.rb') && File.file?('config/environment.rb')
+          unless defined?Rack::Adapter::Rails
+            puts "You need the Rack::Adapter::Rails to run Rails apps with RackBox." + 
+                 " Try: sudo gem install thin" unless options[:silent]
+          else
+            @app = Rack::Adapter::Rails.new :root => '.', :environment => 'development'
+          end
+        
+        else
+          puts "RackBox.app not configured." unless options[:silent]
+        
+        end
+      end
+
+      @app
+    end
+
+    # helper method for taking a Hash of params and turning them into POST params
+    #
+    # >> RackBox.build_query :hello => 'there'
+    # => 'hello=there'
+    #
+    # >> RackBox.build_query :hello => 'there', :foo => 'bar'
+    # => 'hello=there&foo=bar' 
+    #
+    # >> RackBox.build_query :user => { :name => 'bob', :password => 'secret' }
+    # => 'user[name]=bob&user[password]=secret' 
+    #
+    def build_query params_hash = { }
+      # check to make sure no values are Hashes ...
+      # if they are, we need to flatten them!
+      params_hash.each do |key, value|
+        # params_hash  :a => { :b => X, :c => Y }
+        # needs to be  'a[b]' => X, 'a[b]' => Y
+        if value.is_a? Hash
+          inner_hash = params_hash.delete key # { :b => X, :c => Y }
+          inner_hash.each do |subkey, subvalue|
+            new_key = "#{ key }[#{ subkey }]" # a[b] or a[c]
+            puts "warning: overwriting query parameter #{ new_key }" if params_hash[new_key]
+            params_hash[new_key] = subvalue # 'a[b]' => X or a[c] => Y
+          end
+          # we really shouldn't keep going thru the #each now that we've altered data!
+          return build_query(params_hash)
+        end
+      end
+      Rack::Utils.build_query params_hash
+    end
+
+  end
+end

data/lib/rackbox/spec.rb

@@ -0,0 +1,10 @@
+# this should get you up and running for using RackBox with RSpec
+require File.dirname(__FILE__) + '/../rackbox'
+
+spec_configuration = nil
+spec_configuration = Spec::Example if defined? Spec::Example
+spec_configuration = Spec::Runner if defined? Spec::Runner
+
+spec_configuration.configure do |config|
+  config.use_blackbox = true
+end

data/lib/rackbox/spec/configuration.rb

@@ -0,0 +1,75 @@
+# Extend the RSpec configuration class with a use_blackbox option
+#
+# To add blackbox testing to a Rails app,
+# in your spec_helper.rb
+#
+#   require 'rackbox'
+#
+#   Spec::Runner.configure do |config|
+#     config.use_blackbox = true
+#   end
+#
+
+spec_configuration_class = nil
+spec_configuration_class = Spec::Example::Configuration if defined? Spec::Example::Configuration
+spec_configuration_class = Spec::Runner::Configuration if defined? Spec::Runner::Configuration
+
+if spec_configuration_class
+  spec_configuration_class.class_eval do
+    # Adds blackbox testing to your Rails application using RackBox.
+    #
+    # To use, put your 'blackbox' specs into the spec/blackbox
+    # directory, eg. spec/blackbox/login_spec.rb
+    #
+    # In these specs, the RackBox::SpecHelpers#req method will be available to you
+    #
+    def use_blackbox= bool
+      if bool == true
+        
+        before(:all, :type => :blackbox) do
+          self.class.instance_eval {
+            # include our own helpers, eg. RackBox::SpecHelpers#req
+            include RackBox::SpecHelpers
+            include RackBox::Matchers
+
+            # include generated url methods, eg. login_path.
+            # default_url_options needs to have a host set for the Urls to work
+            if defined?ActionController::UrlWriter
+              include ActionController::UrlWriter
+              default_url_options[:host] = 'example.com'
+            end
+
+            # if we're not in a Rails app, let's try to load matchers from Webrat
+            unless defined?RAILS_ENV
+              begin
+                require 'webrat'
+                require 'webrat/core/matchers'
+                include Webrat::HaveTagMatcher
+                # include Webrat::HasContent
+              rescue LoadError
+                puts "Webrat not available.  have_tag & other matchers won't be available.  to install, sudo gem install webrat"
+              end
+            end
+
+            attr_accessor :rackbox_request
+          }
+        end
+
+        before(:each, :type => :blackbox) do
+
+          # i'm sure there's a better way to write this!
+          #
+          # i believe metaid would write this as:
+          #   metaclass.class_eval do ... end
+          #
+          (class << self; self; end).class_eval do 
+            include RackBox::Matchers
+          end
+
+          @rackbox_request = Rack::MockRequest.new RackBox.app
+        end
+
+      end
+    end
+  end
+end

data/lib/rackbox/spec/helpers.rb

@@ -0,0 +1,23 @@
+class RackBox
+
+  # Helper methods to include in specs that want to use blackbox testing
+  #
+  # TODO For backwards compatibility, I would like to keep a SpecHelpers
+  #      module, but this needs to be renamed because this isn't spec 
+  #      specific at all!  it needs to be easy to RackBox::App.new(rack_app).request
+  #      or something like that (something generic)
+  #
+  # This module has the RackBox::SpecHelpers#request method, which is 
+  # the main method used by RackBox blackbox tests
+  #
+  module SpecHelpers
+
+    # moved logic into RackBox#request, where it can easily be re-used
+    def req url, options = {}
+      RackBox.request @rackbox_request, url, options
+    end
+
+    alias request req unless defined? request
+
+  end
+end

data/lib/rackbox/test.rb

@@ -0,0 +1 @@
+# this should get you up and running for using RackBox with test/unit

data/lib/rspec/custom_matcher.rb

@@ -0,0 +1,52 @@
+# created by: http://github.com/xdotcommer
+# from: http://github.com/xdotcommer/rspec-custom-matchers/blob/0ecfccd659d5038cdfc88fdc1fee08373e1ee75c/custom_matcher.rb
+class CustomMatcher
+  def self.create(class_name, &block)
+    klass = Class.new(CustomMatcher)
+    klass.send(:define_method, :matcher, &block) if block_given?
+    Object.const_set(build_class_name(class_name), klass)
+  end
+  
+  def initialize(expected = nil)
+    @expected = expected
+  end
+  
+  def failure_message
+    message
+  end
+
+  def negative_failure_message
+    message(false)
+  end
+  
+  def matcher(target, expected)
+    target == expected
+  end
+  
+  def matches?(target)
+    @target = target
+    if self.method(:matcher).arity == 2
+      matcher(@target, @expected)
+    else
+      matcher(@target)
+    end
+  end
+  
+private
+  def message(positive = true)
+    "#{positive ? 'Expected' : 'Did not expect'} #{@target.inspect} to #{class_display_name} #{@expected.inspect if self.method(:matcher).arity == 2}"
+  end
+  
+  def class_display_name
+    self.class.to_s.gsub(/[A-Z]/) {|m| ' ' + m.downcase }.lstrip
+  end
+  
+  def self.build_class_name(class_name)
+    class_name.to_s.split('_').map {|s| s.capitalize}.join
+  end
+end
+
+def matcher(name, context = self.class, &block)
+  klass = CustomMatcher.create(name, &block)
+  context.send(:define_method, name) { |*args| klass.new(*args) }
+end