merb 0.5.3 → 0.9.2

data/spec/merb/core_ext/inflector_spec.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Inflector do
-  it "should transform words from singular to plural" do
-    "post".pluralize.should == "posts"
-    "octopus".pluralize.should =="octopi"
-    "the blue mailman".pluralize.should == "the blue mailmen"
-    "CamelOctopus".pluralize.should == "CamelOctopi"
-  end
-  
-  it "should transform words from plural to singular" do
-    "posts".singularize.should == "post"
-    "octopi".singularize.should == "octopus"
-    "the blue mailmen".singularize.should == "the blue mailman"
-    "CamelOctopi".singularize.should == "CamelOctopus"
-  end
-  
-  it "should transform class names to table names" do
-    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
-    "egg_and_ham".tableize.should == "egg_and_hams"
-    "fancyCategory".tableize.should == "fancy_categories"
-  end
-  
-  it "should tranform table names to class names" do
-    "egg_and_hams".classify.should == "EggAndHam"
-    "post".classify.should == "Post"
-  end
-  
-  it "should create a foreign key name from a class name" do
-    "Message".foreign_key.should == "message_id"
-    "Message".foreign_key(false).should == "messageid"
-    "Admin::Post".foreign_key.should == "post_id"
-  end
-end

data/spec/merb/core_ext/kernel_spec.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "extracting options from arguments" do
-  def the_method(*args)
-    [extract_options_from_args!(args), args]
-  end
-  
-  it "should extract the hash if the last item is a hash" do
-    opts,args = the_method(:one, :two, :key => :value)
-    opts.should == { :key => :value }
-    args.should == [:one, :two]
-  end
-  
-  it "should return nil for the opts if no hash is provided" do
-    opts,args = the_method(:one, :two)
-    opts.should be_nil
-    args.should == [:one, :two]
-  end
-  
-  it "should return two hashes" do
-    opts,args = the_method({ :one => :two }, { :key => :value })
-    opts.should == {:key => :value}
-    args.should == [{:one => :two}]
-  end
-end

data/spec/merb/core_ext/numeric_spec.rb

@@ -1,26 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "A Numeric object" do
-  it "should be able to convert to US currency" do
-    1.5.to_currency.should == "$1.50"
-  end
-  
-  it "should be able to convert to Danish currency" do
-    15_000_000.5.to_currency(nil, ".", ",", "DM").should == "15.000.000,50DM"
-  end
-  
-  {
-    :microsecond => Float(10 ** -6), :millisecond => Float(10 ** -3), :second => 1,
-    :minute => 60, :hour => 3600, :day => 86400, :week => 604800,
-    :month => 2592000, :year => 31536000, :decade => 315360000
-  }.each do |method,seconds|
-    
-    it "should be able to convert to #{method}s (singular version)" do
-      1.send(method).should == seconds
-    end
-    
-    it "should be able to convert to #{method}s (plural version)" do
-      2.send("#{method}s").should == seconds * 2
-    end
-  end
-end

data/spec/merb/core_ext/object_spec.rb

@@ -1,47 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-class String
-  def self.define_meta(meth, val)
-    meta_def(meth) { val }
-  end
-end
-class MyString < String; end
-
-describe "An object" do
-  it "should be able to return a passed in object that is modified by a block" do
-    (returning({}) {|x| x.merge!(:foo => :bar)}).should == {:foo => :bar}
-  end
-  
-  it "should be able to get a meta class" do
-    MyString.meta_class.to_s.should == "#<Class:MyString>"
-  end
-  
-  it "should be able to execute code in the meta-class' context" do
-    (MyString.meta_eval { self }).should == MyString.meta_class
-  end
-  
-  it "should be able to define a method on the meta-class" do
-    MyString.define_meta :foo, :bar
-    MyString.foo.should == :bar
-  end
-  
-  it "should be able to define methods on its instances" do
-    MyString.class_def(:foo) { :bar }
-    MyString.new.foo.should == :bar
-  end
-  
-  {[] => true,
-   [1] => false,
-   [nil] => false,
-   nil => true,
-   true => false,
-   false => true,
-   "" => true,
-   "   " => true,
-   "  hey " => false
-  }.each do |obj, expected|
-    it "should be able to determine whether the #{obj.class} #{obj.inspect} is blank" do
-      obj.blank?.should == expected
-    end
-  end
-end

data/spec/merb/core_ext/string_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "A String" do
-  it "should convert a path/like/this to a Constant::String::Like::This" do
-    "path/like/this".to_const_string.should == "Path::Like::This"
-    "path".to_const_string.should == "Path"
-    "snake_case/path/with_several_parts".to_const_string.should == "SnakeCase::Path::WithSeveralParts"
-  end
-  
-  it "should raise an error rather than freeze when trying to convert bad Paths/12Like/-this" do
-    Timeout::timeout(1) do
-      lambda do
-        "Paths/12Like/-this".to_const_string
-      end.should raise_error(String::InvalidPathConversion)
-    end.should_not raise_error(Timeout::Error)
-  end
-
-  it "should remove any indentation and add +indentation+ number of spaces" do
-    "foo\n  bar\n".indent(3).should == "   foo\n     bar\n"
-    "  foo\n    bar\n".indent(3).should == "   foo\n     bar\n"
-  end
-end

data/spec/merb/core_ext/symbol_spec.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Symbol do
-  it "should be able to call Symbol#to_proc" do
-    ['foo', 'bar'].map(&:reverse).should == ['oof', 'rab']
-  end
-end

data/spec/merb/dependency_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Kernel#dependency" do
-    
-  before do
-    File.stub!(:directory?).with(Merb.root / "gems").and_return(true)
-    Gem.stub!(:use_paths)
-    Gem.stub!(:clear_paths)
-  end
-    
-  it "loads in files from the local gem-cache first" do
-    Gem.should_receive(:activate).with("json_pure", true).and_return(true)
-    Kernel.dependency "json_pure"
-  end
-  
-  it "does a require if it can't find it in either gem cache" do
-    Gem.stub!(:activate).twice.with("RedCloth", true).and_raise(LoadError)
-    Kernel.should_receive(:require).with("RedCloth")
-    Kernel.dependency "RedCloth"
-  end
-  
-end

data/spec/merb/dispatch_spec.rb

@@ -1,528 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require_fixtures '/controllers/dispatch_spec_controllers'
-
-describe Merb::Dispatcher do
-  before :all do
-    Merb::Config[:allow_reloading] = false
-    Merb::Router.prepare do |r|
-      r.resource :icon
-      r.resources :posts,
-        :member => { :stats => [:get, :put] },
-        :collection => { :filter => [:get] } do |post|
-        post.resources :comments,  :member => { :stats => [:get, :put] }
-        post.resource :profile
-      end
-      r.resources :as do |a|
-        a.resources :bs do |b|
-          b.resources :cs
-        end  
-      end
-      
-      r.match('/admin') do |admin|
-        admin.resources :tags
-      end
-      
-      r.default_routes
-    end
-  end
-  
-  it "should not overwrite url params with query string params" do
-    controller, action = request(:get, '/foo/bar/42?id=24')
-    controller.class.should == Foo
-    action.should == "bar"
-    controller.params[:id].should == '42'
-  end
-  
-  it "should not allow private and protected methods to be called" do
-    controller, action = request(:get, '/foo/call_filters')
-    controller.status.should == Merb::ControllerExceptions::ActionNotFound::STATUS
-  end
-  
-  it "should handle request: GET /foo/bar and return Foo#bar" do
-    controller, action = request(:get, '/foo/bar')
-    e = controller.params[:exception]
-    controller.class.should == Foo
-    action.should == "bar"
-    controller.body.should == "bar"
-  end
-  
-  it "should handle request: GET /foo/bar/1.xml and return Foo#bar format xml" do
-    controller, action = request(:get, '/foo/bar/1.xml')
-    controller.class.should == Foo
-    controller.params[:format].should == 'xml'
-    action.should == "bar"
-    controller.body.should == "bar"
-  end
-  
-  it "should handle request: GET /foo/bar.xml and return Foo#bar format xml" do
-    controller, action = request(:get, '/foo/bar.xml')
-    controller.class.should == Foo
-    controller.params[:format].should == 'xml'
-    action.should == "bar"
-    controller.body.should == "bar"
-  end
-  
-  it "should handle request: GET /foo.xml and return Foo#index format xml" do
-    controller, action = request(:get, '/foo.xml')
-    controller.class.should == Foo
-    controller.params[:format].should == 'xml'
-    action.should == "index"
-    controller.body.should == "index"
-  end
-  
-  it "should handle request: GET /foo and return Foo#index" do
-    controller, action = request(:get, '/foo')
-    controller.class.should == Foo
-    action.should == "index"
-    controller.body.should == "index"
-  end
-  
-  it "should handle request: GET /icon and return Icon#show" do
-    controller, action = request(:get, '/icon')
-    controller.class.should == Icon
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /icon.xml and return Icon#show format xml" do
-    controller, action = request(:get, '/icon.xml')
-    controller.class.should == Icon
-    action.should == "show"
-    controller.params[:format].should == 'xml'
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /icon/new and return Icon#new" do
-    controller, action = request(:get, '/icon/new')
-    controller.class.should == Icon
-    action.should == "new"
-    controller.body.should == :new
-  end
-  
-  it "should handle request: GET /icon;edit and return Icon#edit" do
-    controller, action = request(:get, '/icon;edit')
-    controller.class.should == Icon
-    action.should == "edit"
-    controller.body.should == :edit
-  end
-  
-  it "should handle request: GET /icon/edit and return Icon#edit" do
-    controller, action = request(:get, '/icon/edit')
-    controller.class.should == Icon
-    action.should == "edit"
-    controller.body.should == :edit
-  end
-  
-  it "should handle request: POST /icon and return Icon#create" do
-    controller, action = request(:post, '/icon')
-    controller.class.should == Icon
-    action.should == "create"
-    controller.body.should == :create
-  end
-  
-  it "should handle request: PUT /icon and return Icon#update" do
-    controller, action = request(:put, '/icon')
-    controller.class.should == Icon
-    action.should == "update"
-    controller.body.should == :update
-  end
-  
-  it "should handle request: DELETE /icon and return Icon#destroy" do
-    controller, action = request(:delete, '/icon')
-    controller.class.should == Icon
-    action.should == "destroy"
-    controller.body.should == :destroy
-  end
-  
-  it "should handle request: GET /admin/tags and return Tags#index" do
-    controller, action = request(:get, '/admin/tags')
-    controller.class.should == Tags
-    action.should == "index"
-    controller.body.should == :index
-  end
-  
-  it "should handle request: GET /admin/tags.xml and return Tags#index format xml" do
-    controller, action = request(:get, '/admin/tags.xml')
-    controller.class.should == Tags
-    action.should == "index"
-    controller.params[:format].should == 'xml'
-    controller.body.should == :index
-  end
-  
-  it "should handle request: GET /posts and return Posts#index" do
-    controller, action = request(:get, '/posts')
-    controller.class.should == Posts
-    action.should == "index"
-    controller.body.should == :index
-  end
-  
-  it "should handle request: GET /posts;filter and return Posts#filter" do
-    controller, action = request(:get, '/posts;filter')
-    controller.class.should == Posts
-    action.should == "filter"
-    controller.body.should == :filter
-  end
-  
-  it "should handle request: GET /posts/filter and return Posts#filter" do
-    controller, action = request(:get, '/posts/filter')
-    controller.class.should == Posts
-    action.should == "filter"
-    controller.body.should == :filter
-  end
-  
-  it "should handle request: GET /posts/1/comments and return Comments#index with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments')
-    controller.class.should == Comments
-    action.should == "index"
-    controller.body.should == :index
-  end
-  
-  it "should handle request: GET /posts/1/profile and return Profile#show with post_id == 1" do
-    controller, action = request(:get, '/posts/1/profile')
-    controller.class.should == Profile
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /posts/1/profile.xml and return Profile#show with post_id == 1" do
-    controller, action = request(:get, '/posts/1/profile.xml')
-    controller.class.should == Profile
-    controller.params[:format].should == 'xml'
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /posts.xml and return Posts#index format xml" do
-    controller, action = request(:get, '/posts.xml')
-    controller.class.should == Posts
-    controller.params[:format].should == 'xml'
-    action.should == "index"
-    controller.body.should == :index
-  end
-  
-  it "should handle request: GET /posts/1 and return Posts#show" do
-    controller, action = request(:get, '/posts/1')
-    controller.class.should == Posts
-    action.should == "show"
-    controller.params[:id].should == '1'
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /posts/1/comments/1 and return Comments#show with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1')
-    controller.class.should == Comments
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /as/1/bs/1 and return Bs#show with as_id == 1 & id == 1" do
-    controller, action = request(:get, '/as/1/bs/1')
-    controller.class.should == Bs
-    controller.params[:id].should == '1'
-    controller.params[:a_id].should == '1'
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /as/1/bs/1/cs and return Cs#show with a_id == 1 & b_id == 1" do
-    controller, action = request(:get, '/as/1/bs/1/cs')
-    controller.class.should == Cs
-    controller.params[:b_id].should == '1'
-    controller.params[:a_id].should == '1'
-    action.should == "index"
-    controller.body.should == :index
-  end
-  
-  it "should handle request: GET /as/1/bs/1/cs/1  and return Bs#show with as_id == 1 & b_id == 1 & id == 1" do
-    controller, action = request(:get, '/as/1/bs/1/cs/1')
-    controller.class.should == Cs
-    controller.params[:id].should == '1'
-    controller.params[:a_id].should == '1'
-    controller.params[:b_id].should == '1'
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /posts/1.xml and return Posts#show format xml" do
-    controller, action = request(:get, '/posts/1.xml')
-    controller.class.should == Posts
-    controller.params[:format].should == 'xml'
-    action.should == "show"
-    controller.params[:id].should == '1'
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /posts/1/comments/1.xml and return Comments#show with post_id == 1 and format xml" do
-    controller, action = request(:get, '/posts/1/comments/1.xml')
-    controller.class.should == Comments
-    controller.params[:id].should == '1'
-    controller.params[:format].should == 'xml'
-    controller.params[:post_id].should == '1'
-    action.should == "show"
-    controller.body.should == :show
-  end
-  
-  it "should handle request: GET /posts/new and return Posts#new" do
-    controller, action = request(:get, '/posts/new')
-    controller.class.should == Posts
-    action.should == "new"
-    controller.body.should == :new
-  end
-  
-  it "should handle request: GET /posts/1/comments/new and return Comments#new with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/new')
-    controller.class.should == Comments
-    action.should == "new"
-    controller.body.should == :new
-  end
-  
-  it "should handle request: GET /posts/1;edit and return Posts#edit" do
-    controller, action = request(:get, '/posts/1;edit')
-    controller.class.should == Posts
-    action.should == "edit"
-    controller.params[:id].should == '1'
-    controller.body.should == :edit
-  end
-  
-  it "should handle request: GET /posts/1/edit and return Posts#edit" do
-    controller, action = request(:get, '/posts/1/edit')
-    controller.class.should == Posts
-    action.should == "edit"
-    controller.params[:id].should == '1'
-    controller.body.should == :edit
-  end
-  
-  it "should handle request: GET /posts/1/comments/1;edit and return Comments#edit with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1;edit')
-    controller.class.should == Comments
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    action.should == "edit"
-    controller.body.should == :edit
-  end
-  
-  it "should handle request: GET /posts/1/comments/1/edit and return Comments#edit with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1/edit')
-    controller.class.should == Comments
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    action.should == "edit"
-    controller.body.should == :edit
-  end
-  
-  it "should handle request: POST /posts and return Posts#create" do    
-    controller, action = request(:post, '/posts')
-    controller.class.should == Posts
-    action.should == "create"
-    controller.body.should == :create
-  end
-  
-  it "should handle request: POST /posts/1/comments and return Comments#create  with post_id == 1" do    
-    controller, action = request(:post, '/posts/1/comments')
-    controller.class.should == Comments
-    action.should == "create"
-    controller.body.should == :create
-  end
-  
-  it "should handle request: POST /posts/1/comments.xml and return Comments#create  with post_id == 1 and format xml" do    
-    controller, action = request(:post, '/posts/1/comments.xml')
-    controller.class.should == Comments
-    controller.params[:format].should == 'xml'
-    action.should == "create"
-    controller.body.should == :create
-  end
-  
-  it "should handle request: POST /posts.xml and return Posts#create format xml" do    
-    controller, action = request(:post, '/posts.xml')
-    controller.class.should == Posts
-    controller.params[:format].should == 'xml'
-    action.should == "create"
-    controller.body.should == :create
-  end
-  
-  it "should handle request: PUT /posts/1 and return Posts#update" do
-    controller, action = request(:put, '/posts/1')
-    controller.class.should == Posts
-    action.should == "update"
-    controller.params[:id].should == '1'
-    controller.body.should == :update
-  end
-  
-  it "should handle request: PUT /posts/1/comments/1 and return Comments#update with post_id == 1" do
-    controller, action = request(:put, '/posts/1/comments/1')
-    controller.class.should == Comments
-    action.should == "update"
-    controller.params[:post_id].should == '1'
-    controller.params[:id].should == '1'
-    controller.body.should == :update
-  end
-  
-  it "should handle request: PUT /posts/1.xml and return Posts#update format xml" do    
-    controller, action = request(:put, '/posts/1.xml')
-    controller.class.should == Posts
-    controller.params[:format].should == 'xml'
-    controller.params[:id].should == '1'
-    action.should == "update"
-    controller.body.should == :update
-  end
-  
-  it "should handle request: PUT /posts/1/comments/1.xml and return Comments#update with post_id == 1 and format xml" do
-    controller, action = request(:put, '/posts/1/comments/1.xml')
-    controller.class.should == Comments
-    action.should == "update"
-    controller.params[:post_id].should == '1'
-    controller.params[:format].should == 'xml'
-    controller.params[:id].should == '1'
-    controller.body.should == :update
-  end
-  
-  it "should handle request: DELETE /posts/1 and return Posts#destroy" do
-    controller, action = request(:delete, '/posts/1')
-    controller.class.should == Posts
-    controller.params[:id].should == '1'
-    action.should == "destroy"
-    controller.body.should == :destroy
-  end
-  
-  it "should handle request: DELETE /posts/1/comments/1 and return Comments#destroy with post_id == 1" do
-    controller, action = request(:delete, '/posts/1/comments/1')
-    controller.class.should == Comments
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    action.should == "destroy"
-    controller.body.should == :destroy
-  end
-  
-  it "should handle request: DELETE /posts/1.xml and return Posts#destroy format xml" do    
-    controller, action = request(:delete, '/posts/1.xml')
-    controller.class.should == Posts
-    controller.params[:format].should == 'xml'
-    controller.params[:id].should == '1'
-    action.should == "destroy"
-    controller.body.should == :destroy
-  end
-  
-  it "should handle request: DELETE /posts/1/comments/1.xml and return Comments#destroy with post_id == 1" do
-    controller, action = request(:delete, '/posts/1/comments/1.xml')
-    controller.class.should == Comments
-    controller.params[:id].should == '1'
-    controller.params[:format].should == 'xml'
-    controller.params[:post_id].should == '1'
-    action.should == "destroy"
-    controller.body.should == :destroy
-  end
-  
-  it "should handle request: GET /posts/1;stats and return Posts#stats" do
-    controller, action = request(:get, '/posts/1;stats')
-    controller.class.should == Posts
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should handle request: GET /posts/1/stats and return Posts#stats" do
-    controller, action = request(:get, '/posts/1/stats')
-    controller.class.should == Posts
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should handle request: GET /posts/1/comments/1;stats and return Comments#stats with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1;stats')
-    controller.class.should == Comments
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should handle request: GET /posts/1/comments/1/stats and return Comments#stats with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1/stats')
-    controller.class.should == Comments
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should handle request: PUT /posts/1;stats and return Posts#stats" do
-    controller, action = request(:put, '/posts/1;stats')
-    controller.class.should == Posts
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should handle request: PUT /posts/1/comments/1;stats and return Comments#stats with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1;stats')
-    controller.class.should == Comments
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should handle request: PUT /posts/1/comments/1/stats and return Comments#stats with post_id == 1" do
-    controller, action = request(:get, '/posts/1/comments/1/stats')
-    controller.class.should == Comments
-    action.should == 'stats'
-    controller.params[:id].should == '1'
-    controller.params[:post_id].should == '1'
-    controller.body.should == :stats
-  end
-  
-  it "should show the custom error page" do
-    controller, action = request(:get, '/foo/error')
-    controller.body.should == "oh no!"
-  end
-  
-  it "should show the a 404 error page" do
-    controller, action = request(:get, '/foo/raise404')
-    controller.status.should == Merb::ControllerExceptions::NotFound::STATUS
-  end
-  
-  it "should not show the a 404 error page if you call with upcase url" do
-    controller, action = request(:get, '/Posts/1')
-    controller.status.should == Merb::ControllerExceptions::NotFound::STATUS
-  end
-  
-  it "should not show the a 404 error page if you call with - in the controller name with no explicit route" do
-    controller, action = request(:get, '/pos-ts/1')
-    controller.status.should == Merb::ControllerExceptions::NotFound::STATUS
-  end
-  
-  if defined?(ParseTreeArray)
-    it "should support parameterized actions with required arguments" do
-      controller, action = request(:get, '/bar/foo/1')
-      controller.body.should == "1"
-    end
-    
-    it "should support parameterized actions with required and optional arguments" do
-      controller, action = request(:get, '/bar/bar?a=1&b=3')
-      controller.body.should == "1 3"
-    end
-    
-    it "should use optional arguments in parameters if they exist" do
-      controller, action = request(:get, '/bar/bar?a=1')
-      controller.body.should == "1 2"
-    end
-    
-    it "should use optional arguments even if a later argument is provided" do
-      controller, action = request(:get, '/bar/baz?a=1&c=5')
-      controller.body.should == "1 2 5"
-    end
-    
-    it "should support actionargs with false as defaults" do
-      controller, action = request(:get, '/bar/bat?a=1')
-      controller.body.should == "1 false"
-    end
-    
-    it "should support actionargs with nil as defaults" do
-      controller, action = request(:get, '/bar/bam?a=1')
-      controller.body.should == "1 nil"
-    end
-  end
-end