eol_rackbox 1.1.7

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 ryan "remi" Taylor
+
+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/RDOC_README.rdoc

@@ -0,0 +1,88 @@
+= RackBox
+
+RackBox adds Merb-style blackbox testing]blackbox] to Rack apps (including Rails)
+
+This currently only works with RSpec.
+
+== Screencast
+
+Watch the Screencast[http://remi.org/2009/01/29/introducing-rackbox_merb-esque-blackbox-testing-for-rack-and-rails-apps.html]
+
+== Installation
+
+    $ sudo gem install remi-rackbox -s http://gems.github.com
+
+NOTE: right now, RackBox requires thin.  Soon, I'll likely remove thin as 
+a dependency and will only require rack.
+
+== Rails (fast!)
+
+    $ sudo gem install rspec rspec-rails thin
+    $ sudo gem install remi-rackbox -s http://gems.github.com
+
+    $ rails new_app
+    $ cd new_app
+    $ ./script/generate rspec
+    $ ./script/generate blackbox_spec Home Page
+
+    $ rake spec
+    
+
+== Rails (manual)
+
+To write RackBox tests in Rails apps, make a `blackbox` directory under your `spec` directory 
+and add this to the Spec configure block in your `spec_helper.rb` file:
+
+    config.use_blackbox = true
+
+Also, add `require 'rackbox'` to the top of your `spec_helper.rb`
+
+You can see a working example of blackbox testing a Rails application here: examples/rails](http://github.com/remi/rackbox/tree/master/examples/rails)
+
+== Rack
+
+To write RackBox tests in Rack apps, I'm currently assuming that you have a `config.ru` rackup file. 
+If so, your app should load, otherwise you can explicitly configure RackBox to read your Rack app:
+
+    RackBox.app = your Rack app]
+
+Basides that, the configuration is the same as Rails.  Make a `blackbox` directory under your 
+`spec` directory and add this to the Spec configure block in your `spec_helper.rb` file:
+
+    config.use_blackbox = true
+
+Also, add `require 'rackbox'` to the top of your `spec_helper.rb`
+
+You can see a working example of blackbox testing a Rack application here: examples/rack](http://github.com/remi/rackbox/tree/master/examples/rack)
+
+NOTE: If you want to be able to use nice RSpec matchers like `request('/').should have_tag('p')` in your 
+blackbox specs in your Rack apps, you should `sudo gem install webrat` and RackBox will include 
+Webrat's helpers in your specs.
+
+== Usage
+
+Ideally, the usage of RackBox should be identical to Merb-style blackbox testing.  I need to find good documentation 
+on how things work in Merb so I can duplicate any functionality I'm missing.  For now, it's really simple!
+
+    describe Foo do
+
+      it 'should have foxes on the home page' do
+        request('/').body.should include('Foxes')
+      end
+
+      it 'should let me know that I was logged in' do
+        response = request(login_path, :method => :post, :params => { 'user' => 'bob', :password => 'secret' })
+        response.body.should include('Welcome bob, you were successfully logged in!')
+      end
+
+    end
+
+`request` gives you a `Rack::Response`](http://rack.rubyforge.org/doc/classes/Rack/Response.html) which has 
+`body`, `headers`, `status` methods (and more](http://rack.rubyforge.org/doc/classes/Rack/Response.html))
+
+== TODO
+
+* request('/', :data => 'some XML or something')
+* request('/', :format => :json)          # simple helpers for content type request accepts
+* request('/', 'Content-Length' => 'x')   # anything passed in that we don't handle, throw into the request ENV ... but :content_length should work too?
+* get usage documentation working for `./script/generate blackbox_spec`

data/README.markdown

@@ -0,0 +1,134 @@
+RackBox
+=======
+
+[RackBox][] adds [Merb][]-style [blackbox testing][blackbox] to [Rack][] apps (including [Rails][])
+
+This currently only works with [RSpec][].
+
+DEPRECATED
+----------
+
+**NOTE**: Although I really love the RackBox syntax (which was stolen from Merb's request spec), 
+rack-test has gotten much more love than RackBox and I haven't had time to refactor RackBox.
+
+I recommend using rack-test instead!  RackBox will likely be ported to a rack-test extension 
+that provides the syntax I enjoy.
+
+Screencast
+----------
+
+[Watch the 'Screencast'][screencast]
+
+Installation
+------------
+
+    $ sudo gem install remi-rackbox -s http://gems.github.com
+
+NOTE: right now, [RackBox][] requires [thin][].  Soon, I'll likely remove [thin][] as 
+a dependency and will only require [rack][].
+
+Rails (fast!)
+-------------
+
+    $ sudo gem install rspec rspec-rails thin
+    $ sudo gem install remi-rackbox -s http://gems.github.com
+
+    $ rails new_app
+    $ cd new_app
+    $ ./script/generate rspec
+    $ ./script/generate blackbox_spec Home Page
+
+    $ rake spec
+    
+
+Rails (manual)
+--------------
+
+To write [RackBox][] tests in [Rails][] apps, make a `blackbox` directory under your `spec` directory 
+and add this to the Spec configure block in your `spec_helper.rb` file:
+
+    config.use_blackbox = true
+
+Also, add `require 'rackbox'` to the top of your `spec_helper.rb`
+
+You can see a working example of blackbox testing a [Rails][] application here: [examples/rails](http://github.com/remi/rackbox/tree/master/examples/rails)
+
+Rack
+----
+
+To write [RackBox][] tests in [Rack][] apps, I'm currently assuming that you have a `config.ru` rackup file. 
+If so, your app should load, otherwise you can explicitly configure [RackBox][] to read your [Rack][] app:
+
+    RackBox.app = [your Rack app]
+
+Basides that, the configuration is the same as [Rails][].  Make a `blackbox` directory under your 
+`spec` directory and add this to the Spec configure block in your `spec_helper.rb` file:
+
+    config.use_blackbox = true
+
+Also, add `require 'rackbox'` to the top of your `spec_helper.rb`
+
+You can see a working example of blackbox testing a [Rack][] application here: [examples/rack](http://github.com/remi/rackbox/tree/master/examples/rack)
+
+NOTE: If you want to be able to use nice RSpec matchers like `request('/').should have_tag('p')` in your 
+blackbox specs in your [Rack][] apps, you should `sudo gem install webrat` and [RackBox][] will include 
+[Webrat][]'s helpers in your specs.
+
+Usage
+-----
+
+Ideally, the usage of [RackBox][] should be identical to [Merb][]-style blackbox testing.  I need to find good documentation 
+on how things work in [Merb][] so I can duplicate any functionality I'm missing.  For now, it's really simple!
+
+    describe Foo do
+
+      it 'should have foxes on the home page' do
+        request('/').body.should include('Foxes')
+      end
+
+      it 'should let me know that I was logged in' do
+        response = request(login_path, :method => :post, :params => { 'user' => 'bob', :password => 'secret' })
+        response.body.should include('Welcome bob, you were successfully logged in!')
+      end
+
+    end
+
+`request` gives you a [`Rack::Response`](http://rack.rubyforge.org/doc/classes/Rack/Response.html) which has 
+`body`, `headers`, `status` methods ([and more](http://rack.rubyforge.org/doc/classes/Rack/Response.html))
+
+Script
+------
+
+[RackBox][] also comes with a `rackbox` script.
+
+    # prints usage ... this is all you really need  :)
+    $ rackbox
+
+    # prints out information about the app in the current directory (if found).
+    # this looks like a config.ru or a Rails environment
+    $ rackbox info
+
+    # prints out the response for a call to GET '/' on your application
+    $ rackbox request --method get /foo
+    $ rackbox get /foo
+    $ rackbox /foo
+
+TODO
+----
+
+see [RackBox][]'s [Lighthouse Tickets](http://remitaylor.lighthouseapp.com/projects/27570-rackbox)
+* look at using Rack::Cookies as a cookie jar instead of doing it ourselves
+* look at Rack::NestedParams and see if it can replace our own logic
+
+
+[rackbox]:    http://github.com/remi/rackbox
+[merb]:       http://merbivore.com
+[rack]:       http://rack.rubyforge.org
+[rails]:      http://rubyonrails.org
+[rspec]:      http://rspec.info
+[webrat]:     http://github.com/brynary/webrat
+[thin]:       http://code.macournoyer.com/thin
+[screencast]: http://remi.org/2009/01/29/introducing-rackbox_merb-esque-blackbox-testing-for-rack-and-rails-apps.html
+[rubygem]:    http://www.rubygems.org
+[blackbox]:   http://en.wikipedia.org/wiki/Black_box_testing
+[sinatra]:    http://sinatra.github.com

data/README.rdoc

@@ -0,0 +1,17 @@
+= eol_rackbox
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Jeremy Rice. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "eol_rackbox"
+    s.summary     = "Merb-like BlackBox testing for Rack apps, including Rails"
+    s.email       = "jrice.blue@gmail.com"
+    s.homepage    = "http://github.com/JRice/eol_rackbox"
+    s.description = "Merb-like BlackBox testing for Rack apps, including Rails; requires two rare dependencies: remi-rails-rack-adapter and remi-simplecli, which we available on github"
+    s.authors     = ["Jeremy Rice"]
+    s.files       = FileList["[A-Z]*", "{bin,lib,spec,examples,rails_generators}/**/*"] 
+#    s.add_dependency 'remi-rails-rack-adapter' 
+#    s.add_dependency 'remi-simplecli' 
+    s.executables = "rackbox" 
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'rackbox'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('RDOC_README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('rackbox.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 1
+:minor: 1
+:build: 
+:patch: 7

data/bin/rackbox

@@ -0,0 +1,4 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/rackbox'
+require 'rackbox/bin'
+RackBox::Bin.new( ARGV ).run

data/lib/eol_rackbox.rb

@@ -0,0 +1,18 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'rack'
+require 'rails-rack-adapter' # update this so it's only loaded when/if needed
+
+require 'rackbox/rack/content_length_fix'
+require 'rackbox/rack/sticky_sessions'
+require 'rackbox/rack/extensions_for_rspec'
+
+require 'rackbox/rackbox'
+require 'rackbox/app'
+
+require 'rspec/custom_matcher'
+require 'rackbox/matchers'
+
+require 'rackbox/spec/helpers'
+require 'rackbox/spec/configuration'

data/lib/rackbox/app.rb

@@ -0,0 +1,30 @@
+class RackBox
+
+  # represents a rack appliction
+  #
+  # gives us some helpers on a rack app 
+  # like the ability to use the #request 
+  # method on it easily
+  #
+  class App
+    attr_accessor :rack_app, :mock_request
+
+    def initialize rack_app
+      @rack_app = rack_app
+      reset_request
+    end
+
+    def reset_request
+      @mock_request = Rack::MockRequest.new @rack_app
+    end
+    alias reset reset_request
+
+    # sessions are sticky!
+    #
+    # to reset, @rackbox_app.reset
+    def request url, options = {}
+      RackBox.request @mock_request, url, options
+    end
+  end
+
+end

data/lib/rackbox/bacon.rb

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

data/lib/rackbox/bin.rb

@@ -0,0 +1,183 @@
+require 'optparse'
+require 'simplecli'
+
+class String
+  def indent number_of_spaces = 1
+    self.gsub(/^(.*)$/, (' ' * number_of_spaces) + '\1')
+  end
+end
+
+class RackBox::Bin
+  include SimpleCLI
+
+  def initialize *args
+    @default_command = :request
+    super
+  end
+
+  def usage *args
+    puts <<doco
+
+  rackbox == %{ For hitting your Rack applications }
+
+    Usage:
+      rackbox command [options]
+
+    Examples:
+      rackbox info               # prints app info
+      rackbox commands           # list commands
+      rackbox get /              # request / path
+      rackbox post -d '<XML>' /  # POST data to / path
+      rackbox /                  # GET / 
+      rackbox --data '<XML>'     # POST data to / path
+      rackbox /dogs --xml        # get /dogs, accepting xml
+
+    Options:
+      -a, --app "MyApp.new"      # ruby to eval to get Rack app
+      -r, --require file[.rb]    # ruby file(s) to require
+
+    Further help:
+      rackbox commands         # list all available commands
+      rackbox help <COMMAND>   # show help for COMMAND
+      rackbox help             # show this help message
+
+doco
+  end 
+
+  %w( get post put delete ).each do |http_method|
+    define_method(http_method) do |*args|
+      request *( ['-m', http_method] + args )
+    end
+    define_method("#{http_method}_help") do
+      <<doco
+  Usage: #{ script_name } #{ http_method } '/some/path'
+
+    Summary:
+      Run a #{ http_method.upcase } request against a Rack app
+    end
+doco
+    end
+  end
+
+  def request_help
+    <<doco
+Usage: #{ script_name } request '/some/path'
+
+  Options:
+    -m, --method      The HTTP method to use, default: get
+    -d, --data        Data to that you can PUT/POST, eg. -d '<XML>'
+    -s, --show        What to show, eg. -s body,headers,status or
+                      call multiple times, eg. -s body -s headers
+    -h, --header      Add header to request, eg. -h accept=text/plain
+    -j, --json        Sets 'Accept' header to 'application/json'
+    -x, --xml         Sets 'Accept' header to 'application/xml'
+
+  Summary:
+    Run a request against a Rack app
+  end
+doco
+  end
+  def request *args
+
+    # if args is ampty, we likely just called: $ rackbox
+    # which came to #request because it's the default command, 
+    # so we should print out the usage for rackbox and exit
+    if args.empty?
+      usage
+      exit
+    end
+
+    set_rackbox_app args
+
+    options = {
+      :show => [],
+      :headers => {}
+    }
+    opts = OptionParser.new do |opts|
+      opts.on('-j', '--json'){ options[:headers]['Accept'] = 'application/json' }
+      opts.on('-x', '--xml'){ options[:headers]['Accept'] = 'application/xml' }
+      opts.on('-m','--method [m]'){|m| options[:method] = m }
+      opts.on('-d','--data [d]'){|d| options[:data] = d }
+      opts.on('-s','--show [s]'){|s| options[:show] += s.split(',') }
+      opts.on('-h','--header [h]'){|h|
+        name,value = h.split('=')
+        options[:headers][name] = value
+      }
+    end 
+    opts.parse! args
+
+    rackbox_options = { }
+    rackbox_options[:method] = options[:method] if options[:method]
+    rackbox_options[:data]   = options[:data]   if options[:data]
+
+    options[:headers].each do |name, value|
+      rackbox_options[name] = value
+    end
+
+    url = args.pop
+
+    response = RackBox.request url, rackbox_options
+    options[:show] = %w( body headers status ) if options[:show].empty?
+
+    if options[:show].include? 'body'
+      body_text = ''
+      response.body.each {|str| body_text << str }
+    end
+
+    output = "Response:\n"
+    output << "  Status: #{ response.status }\n" if options[:show].include? 'status'
+    output << "  Headers: \n#{ response.headers.to_yaml.strip.indent(4) }\n" if options[:show].include? 'headers'
+    output << "  Body: \n#{ body_text.indent(4) }\n" if options[:show].include? 'body'
+
+    puts output
+  end
+
+  def info_help
+    <<doco
+Usage: #{ script_name } info
+
+  Summary:
+    Display information about the current Rack application
+  end
+doco
+  end
+  def info *args
+    set_rackbox_app args
+    puts "RackBox.app => #{ RackBox.app( :silent => true ).inspect }"
+  end
+
+  private
+
+  #
+  # we let users pass a ruby string that will return 
+  # the rack app to be used, eg.
+  #
+  # you can also set files to be required ( -r  )
+  #
+  # $ rackbox -r myapp.rb --app 'lambda {|env| [200, {}, "hi!"] }' info
+  # $ rackbox -r myapp.rb,another-file.rb --app 'Sinatra::Application' get '/'
+  # $ rackbox -r myapp --app 'MyApp.new' '/'
+  #
+  def set_rackbox_app args
+    files_to_require = []
+    ruby_to_run      = nil
+
+    opts = OptionParser.new do |opts|
+      opts.on('-r', '--require [file]') {|x| files_to_require << x }
+      opts.on('-a', '--app [ruby]')     {|x| ruby_to_run = x       }
+    end 
+    opts.parse! args
+    
+    files_to_require.each {|file| require file }
+
+    if ruby_to_run
+      begin
+        RackBox.app = eval(ruby_to_run)
+      rescue Exception => ex
+        puts "tried running Ruby code to set RackBox app: #{ ruby_to_run.inspect }"
+        raise ex
+      end
+    end
+  end
+
+end