merb-core 0.9.7 → 0.9.8

data/spec/public/controller/display_spec.rb

@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Merb::Controller, " displaying objects based on mime type" do
-
-  before do
-    Merb::Router.prepare do |r|
-      r.default_routes
-    end
-  end
-
-  it "should default the mime-type to HTML (and raise since there's no to_html)" do
-    running { dispatch_to(Merb::Test::Fixtures::Controllers::DisplayHtmlDefault, :index) }.should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-
-  it "should set headers['Location'] to string provided by :location" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithStringLocation, :index, {}, :http_accept => "application/json").headers['Location'].should =~ /some_resources/
-  end
-
-  it "should set the status to a code provided by :status" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithStatus, :index, {}, :http_accept => "application/json").status.should == 500
-  end
-
-  it "should use a template if specified" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :index).body.should match(/Custom: Template/)
-  end
-
-  it "overrides layout settings with render :layout => false" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :no_layout).body.should_not match(/Custom: Template/)
-  end
-  
-  it "should accept an absolute template path argument - with the mimetype extension" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :absolute_with_mime).body.should == "Custom: HTML: Default"
-  end
-  
-  it "should accept an absolute template path argument - without the mimetype extension" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :absolute_without_mime).body.should == "Custom: HTML: Default"
-  end
-  
-  it "should accept a relative template path argument - with the mimetype extension" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :relative_with_mime).body.should == "Custom: HTML: Default"
-  end
-  
-  it "should accept a relative template path argument - without the mimetype extension" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :relative_without_mime).body.should == "Custom: HTML: Default"
-  end
-
-  it "should accept a layout argument when calling to_*" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithLayout, :index, {}, 
-      :http_accept => "application/json").body.should == "{custom_arg: { 'include': '', 'exclude': '' }}"
-  end
-  
-  it "should accept a layout argument with a template" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplateArgument, :index).body.should == "Custom Arg: Template"
-  end
-
-  it "should accept a template path argument" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplateArgument, :index_by_arg).body.should == "Template"
-  end
-  
-  it "should use other mime-types if they are provided on the class level" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayClassProvides, :index, {}, :http_accept => "application/xml")
-    controller.body.should == "<XML:Model />"
-  end
-
-  it "should fail if none of the acceptable mime-types are available" do
-    calling { dispatch_to(Merb::Test::Fixtures::Controllers::DisplayClassProvides, :index, {}, :http_accept => "application/json") }.
-      should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-
-  it "should use mime-types that are provided at the local level" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayLocalProvides, :index, {}, :http_accept => "application/xml")
-    controller.body.should == "<XML:Model />"
-  end
-
-  it "passes all options to serialization method like :to_json" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithSerializationOptions, :index, {}, :http_accept => "application/json")
-    controller.body.should == "{ 'include': 'beer, jazz', 'exclude': 'idiots' }"
-  end
-
-  it "passes single argument to serialization method like :to_json" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithSerializationOptions, :index_that_passes_empty_hash, {}, :http_accept => "application/json")
-    controller.body.should == "{ 'include': '', 'exclude': '' }"
-  end
-end

data/spec/public/controller/redirect_spec.rb

@@ -1,33 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Merb::Controller, " redirects" do
-  it "redirects with simple URLs" do
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::SimpleRedirect, :index)
-    @controller.status.should == 302
-    @controller.headers["Location"].should == "/"
-  end
-
-  it "permanently redirects" do
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::PermanentRedirect, :index)
-    @controller.status.should == 301
-    @controller.headers["Location"].should == "/"
-  end
-
-  it "redirects with messages" do
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::RedirectWithMessage, :index)
-    @controller.status.should == 302
-    expected_url = Merb::Request.escape([Marshal.dump(:notice => "what?")].pack("m"))
-    @controller.headers["Location"].should == "/?_message=#{expected_url}"
-  end
-  
-  it "consumes redirects with messages" do
-    message = Merb::Request.escape([Marshal.dump(:notice => "what?")].pack("m"))
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::ConsumesMessage, :index, {:_message => message})
-    @controller.body.should == "\"what?\""
-  end
-  
-  it "supports setting the message for use immediately" do
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::SetsMessage, :index)
-    @controller.body.should == "Hello"
-  end
-end

data/spec/public/controller/responder_spec.rb

@@ -1,169 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Merb::Controller, " responds" do
-  
-  before do
-    Merb.push_path(:layout, File.dirname(__FILE__) / "controllers" / "views" / "layouts")    
-    Merb::Router.prepare do |r|
-      r.default_routes
-    end
-  end
-  
-  it "should default the mime-type to HTML" do
-    dispatch_to(Merb::Test::Fixtures::Controllers::HtmlDefault, :index).body.should == "HTML: Default"
-  end
-
-  it "should use other mime-types if they are provided on the controller-level" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassProvides, :index, {}, :http_accept => "application/xml")
-    controller.body.should == "<XML:Class provides='true' />"
-  end
-
-  it "should fail if none of the acceptable mime-types are available" do
-    calling { dispatch_to(Merb::Test::Fixtures::Controllers::ClassProvides, :index, {}, :http_accept => "application/json") }.
-      should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-
-  it "should use mime-types that are provided at the action-level" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::LocalProvides, :index, {}, :http_accept => "application/xml")
-    controller.body.should == "<XML:Local provides='true' />"
-  end
-  
-  it "should use mime-types that are provided at the controller-level as well as the action-level (controller)" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassAndLocalProvides, :index, {}, :http_accept => "text/html")
-    controller.class_provided_formats.should == [:html]
-    controller._provided_formats.should == [:html, :xml]
-    controller.body.should == "HTML: Class and Local"
-  end  
-  
-  it "should use mime-types that are provided at the controller-level as well as the action-level (action)" do  
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassAndLocalProvides, :index, {}, :http_accept => "application/xml")
-    controller.class_provided_formats.should == [:html]
-    controller._provided_formats.should == [:html, :xml]
-    controller.body.should == "<XML:ClassAndLocalProvides provides='true' />"
-  end
-
-  it "should use the first mime-type when accepting anything */*" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::MultiProvides, :index, {}, :http_accept => "*/*")
-    controller.body.should == "HTML: Multi"
-  end
-
-  it "should pick application/xhtml+xml when both application/xml and application/xhtml+xml are available" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassProvides, 
-      :index, {}, :http_accept => "application/xml,application/xhtml+xml")
-    controller.body.should == "HTML: Wins Over XML If Both Are Specified"
-  end
-
-  it "should use the first mime-type when accepting anything */*, even if something unprovidable comes first" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::HtmlDefault, :index, {}, :http_accept => "application/json, */*")
-    controller.body.should == "HTML: Default"
-  end
-
-  it "should use the pick the first mime-type from the list not the */*" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::MultiProvides, :index, {}, :http_accept => "text/javascript, */*")
-    controller.body.should == "JS: Multi"
-  end
-  
-  it "should pick the first mime-type if no specific supported content-type matches are *available*" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::MultiProvides, :index, {}, :http_accept => "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, */*")
-    controller.body.should == "HTML: Multi"
-  end
-
-  it "should pick the first mime-type if no specific supported content-type matches are actually *provided*" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::MultiProvides, :index, {}, :http_accept => "application/json, */*")
-    controller.body.should == "HTML: Multi"
-  end
-  
-  it "should select the format based on params supplied to it with controller-level provides" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassProvides, :index, :format => "xml")
-    controller.content_type.should == :xml    
-  end
-  
-  it "should select the format based on params supplied to it with action-level provides" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::LocalProvides, :index, :format => "xml")
-    controller.content_type.should == :xml    
-  end
-  
-  it "should select the format based on params supplied to it with controller and action provides (controller)" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassAndLocalProvides, :index, :format => "html")
-    controller.content_type.should == :html
-  end
-  
-  it "should select the format based on params supplied to it with controller and action provides (action)" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassAndLocalProvides, :index, :format => "xml")
-    controller.content_type.should == :xml
-  end
-  
-  it "should properly add formats when only_provides is called in action" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::OnlyProvides, :index, {}, :http_accept => "application/xml")
-    controller._provided_formats.should == [:text, :xml]
-    controller.content_type.should == :xml
-  end
-
-  it "should properly remove formats when only_provides is called in action" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::OnlyProvides, :index, {}, :http_accept => "text/html")
-    lambda { controller.content_type }.should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-
-  it "should properly add formats when only_provides is called in controller" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassOnlyProvides, :index, {}, :http_accept => "application/xml")
-    controller._provided_formats.should == [:text, :xml]
-    controller.content_type.should == :xml
-  end
-
-  it "should properly remove formats when only_provides is called in controller" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassOnlyProvides, :index, {}, :http_accept => "text/html")
-    lambda { controller.content_type }.should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-  
-  it "should properly remove formats when does_not_provide is called in controller" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassDoesntProvides, :index, {}, :http_accept => "text/html")
-    controller._provided_formats.should == [:xml]
-    lambda { controller.content_type }.should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-
-  it "should properly remove formats when does_not_provide is called in action" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::DoesntProvide, :index, {}, :http_accept => "text/html")
-    controller._provided_formats.should == [:xml]
-    lambda { controller.content_type }.should raise_error(Merb::ControllerExceptions::NotAcceptable)
-  end
-  
-  it "should return the correct default HTTP headers for a format" do
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassProvides, :index, :format => "xml")
-    controller.headers.keys.sort.should == ["Content-Type"]
-    controller.headers["Content-Type"].should == "application/xml; charset=utf-8"
-  end
-  
-  it "should append the correct charset which was set when the format was added" do
-    Merb.add_mime_type(:foo, nil, %w[application/foo], :charset => "iso-8859-1")
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :index, :format => "foo")
-    controller.headers["Content-Type"].should == "application/foo; charset=iso-8859-1"
-  end
-  
-  it "should return the correct HTTP headers which were set when the format was added" do
-    Merb.add_mime_type(:foo, nil, %w[application/foo], "Foo" => 'bar', "Content-Language" => "en", :charset => "utf-8")
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :index, :format => "foo")
-    controller.headers.keys.should_not include(:charset)
-    controller.headers["Content-Type"].should == "application/foo; charset=utf-8"
-    controller.headers["Content-Language"].should == "en"
-    controller.headers["Foo"] = "bar"
-  end
-  
-  it "should return the correct HTTP headers using the block given when the format was added" do
-    Merb.add_mime_type(:foo, nil, %w[application/foo], "Foo" => "bar") do |controller|
-      controller.headers["Action-Name"] = controller.action_name
-    end
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :index, :format => "foo")
-    controller.headers["Content-Type"].should == "application/foo"
-    controller.headers["Action-Name"].should == "index"
-    controller.headers["Foo"] = "bar"
-  end
-  
-  it "should not overwrite runtime-set headers with default format response headers" do
-    Merb.add_mime_type(:foo, nil, %w[application/foo], "Foo" => "bar", "Content-Language" => "en")
-    controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :show, :format => "foo")
-    controller.headers["Content-Language"].should == "nl"
-    controller.headers["Biz"] = "buzz"
-    controller.headers["Foo"] = "bar"
-  end
-  
-end

data/spec/public/controller/spec_helper.rb

@@ -1,13 +0,0 @@
-__DIR__ = File.dirname(__FILE__)
-
-require File.join(__DIR__, "..", "..", "spec_helper")
-
-require File.join(__DIR__, "controllers", "base")
-require File.join(__DIR__, "controllers", "responder")
-require File.join(__DIR__, "controllers", "display")
-require File.join(__DIR__, "controllers", "authentication")
-require File.join(__DIR__, "controllers", "redirect")
-require File.join(__DIR__, "controllers", "cookies")
-require File.join(__DIR__, "controllers", "conditional_get")
-
-Merb.start :environment => 'test', :init_file => File.join(__DIR__, 'config', 'init')

data/spec/public/controller/url_spec.rb

@@ -1,255 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-require File.join(File.dirname(__FILE__), "controllers", "url")
-
-class Monkey ; def to_param ; 45 ; end ; end
-class Donkey ; def to_param ; 19 ; end ; end
-class Blue
-  def to_param ; 13 ; end
-  def monkey_id ; Monkey.new ; end
-  def donkey_id ; Donkey.new ; end
-end
-class Pink
-  def to_param ; 22 ; end
-  def blue_id ; Blue.new ; end
-  def monkey_id ; blue_id.monkey_id ; end
-end
-
-Merb::Router.prepare do |r|
-  r.default_routes
-  r.resources :monkeys do |m|
-    m.resources :blues do |b|
-      b.resources :pinks
-    end
-  end
-  r.resources :donkeys do |d|
-    d.resources :blues
-  end
-  r.resource :red do |red|
-    red.resources :blues
-  end
-  r.match(%r{/foo/(\d+)/}).to(:controller => 'asdf').name(:regexp)
-  r.match('/people/:name').
-    to(:controller => 'people', :action => 'show').name(:person)
-  r.match('/argstrs').to(:controller => "args").name(:args)
-end
-
-describe Merb::Controller, " url" do
-  
-  before do
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::Url, :index)
-  end
-  
-  it "should match the :controller to the default route" do
-    @controller.url(:controller => "monkeys").should eql("/monkeys")
-  end
-
-  it "should match the :controller,:action to the default route" do
-    @controller.url(:controller => "monkeys", :action => "list").
-      should eql("/monkeys/list")
-  end
-  
-  it "should match the :controller,:action,:id to the default route" do
-    @controller.url(:controller => "monkeys", :action => "list", :id => 4).
-      should eql("/monkeys/list/4")
-  end
-  
-  it "should match the :controller,:action,:id,:format to the default route" do
-    @controller.url(:controller => "monkeys", :action => "list", :id => 4, :format => "xml").
-      should eql("/monkeys/list/4.xml")
-  end
-  
-  it "should match the :controller,:action,:id,:format,:fragment to the default route" do
-    @controller.url(:controller => "monkeys", :action => "list", :id => 4, :format => "xml", :fragment => :half_way).
-      should eql("/monkeys/list/4.xml#half_way")
-  end
-
-  it "should raise an error" do
-    lambda { @controller.url(:regexp) }.should raise_error
-  end
-
-  it "should match with a route param" do
-    @controller.url(:person, :name => "david").should eql("/people/david")
-  end
-
-  it "should match without a route param" do
-    @controller.url(:person).should eql("/people/")
-  end
-
-  it "should match with an additional param" do
-    @controller.url(:person, :name => 'david', :color => 'blue').should eql("/people/david?color=blue")
-  end
-  
-  it "should match with a :format" do
-    @controller.url(:person, :name => 'david', :format => :xml).should eql("/people/david.xml")
-  end
-  
-  it "should match with a :fragment" do
-    @controller.url(:person, :name => 'david', :fragment => :half_way).should eql("/people/david#half_way")
-  end
-  
-  it "should match with an additional param and :format" do
-    @controller.url(:person, :name => 'david', :color => 'blue', :format => :xml).should eql("/people/david.xml?color=blue")
-  end
-  
-  it "should match with an additional param, :format, and :fragment" do
-    @controller.url(:person, :name => 'david', :color => 'blue', :format => :xml, :fragment => :half_way).
-      should eql("/people/david.xml?color=blue#half_way")
-  end
-  
-  it "should match with additional params" do
-    url = @controller.url(:person, :name => 'david', :smell => 'funky', :color => 'blue')
-    url.should match(%r{/people/david?.*color=blue})
-    url.should match(%r{/people/david?.*smell=funky})
-  end
-
-  it "should match with extra params and an array" do
-    @controller.url(:args, :monkey => [1,2]).should == "/argstrs?monkey[]=1&monkey[]=2"
-  end
-  
-  it "should match with no second arg" do
-    @controller.url(:monkeys).should == "/monkeys"
-  end
-  
-  it "should match with an object as second arg" do
-    @monkey = Monkey.new
-    @controller.url(:monkey, @monkey).should == "/monkeys/45"
-  end
-  
-  it "should match with a fixnum as second arg" do
-    @controller.url(:monkey, 3).should == "/monkeys/3"
-  end
-  
-  it "should match with an object and :format" do
-    @monkey = Monkey.new
-    @controller.url(:monkey, :id => @monkey, :format => :xml).should == "/monkeys/45.xml"
-  end
-  
-  it "should match with an object, :format and additional options" do
-    @monkey = Monkey.new
-    @controller.url(:monkey, :id => @monkey, :format => :xml, :color => "blue").should == "/monkeys/45.xml?color=blue"
-  end
-  
-  it "should match with an object, :format, :fragment, and additional options" do
-    @monkey = Monkey.new
-    @controller.url(:monkey, :id => @monkey, :format => :xml, :color => "blue", :fragment => :half_way).should == "/monkeys/45.xml?color=blue#half_way"
-  end
-
-  it "should match the delete_monkey route" do
-    @monkey = Monkey.new
-    @controller.url(:delete_monkey, @monkey).should == "/monkeys/45/delete"
-  end
-  
-  it "should match the delete_red route" do
-    @controller.url(:delete_red).should == "/red/delete"
-  end
-
-  it "should add a path_prefix to the url if :path_prefix is set" do
-    Merb::Config[:path_prefix] = "/jungle"
-    @controller.url(:monkeys).should == "/jungle/monkeys"
-    Merb::Config[:path_prefix] = nil
-  end
- 
-  it "should match a nested resources show action" do
-    @blue = Blue.new
-    @controller.url(:monkey_blue, @blue).should == "/monkeys/45/blues/13"
-  end
-  
-  it "should match the index action of nested resource with parent object" do
-    @blue = Blue.new
-    @monkey = Monkey.new
-    @controller.url(:monkey_blues, :monkey_id => @monkey).should == "/monkeys/45/blues"
-  end
-  
-  it "should match the index action of nested resource with parent id as string" do
-    @blue = Blue.new
-    @controller.url(:monkey_blues, :monkey_id => '1').should == "/monkeys/1/blues"
-  end
-  
-  it "should match the edit action of nested resource" do
-    @blue = Blue.new
-    @controller.url(:edit_monkey_blue, @blue).should == "/monkeys/45/blues/13/edit"
-  end
-  
-  it "should match the index action of resources nested under a resource" do
-    @blue = Blue.new
-    @controller.url(:red_blues).should == "/red/blues"
-  end
-  
-  it "should match resource that has been nested multiple times" do
-    @blue = Blue.new
-    @controller.url(:donkey_blue, @blue).should == "/donkeys/19/blues/13"
-    @controller.url(:monkey_blue, @blue).should == "/monkeys/45/blues/13"
-  end
-  
-  it "should match resources nested more than one level deep" do
-    @pink = Pink.new
-    @controller.url(:monkey_blue_pink, @pink).should == "/monkeys/45/blues/13/pinks/22"
-  end
-
-  it "should match resource with additional params" do
-    @monkey = Monkey.new
-    @controller.url(:monkey, @monkey, :foo => "bar").should == "/monkeys/45?foo=bar"
-  end
-  it "should match resource with fragment" do
-    @monkey = Monkey.new
-    @controller.url(:monkey, @monkey, :fragment => :half_way).should == "/monkeys/45#half_way"
-  end
-
-  it "should match a nested resource with additional params" do
-    @blue = Blue.new
-    @controller.url(:monkey_blue, @blue, :foo => "bar").should == "/monkeys/45/blues/13?foo=bar"
-  end
-  
-  it "should match a nested resource with additional params and fragment" do
-    @blue = Blue.new
-    @controller.url(:monkey_blue, @blue, :foo => "bar", :fragment => :half_way).should == "/monkeys/45/blues/13?foo=bar#half_way"
-  end
-
-end
-
-
-
-
-describe Merb::Controller, "absolute_url" do
-  before do
-    @controller = dispatch_to(Merb::Test::Fixtures::Controllers::Url, :index)
-  end
-
-  it 'takes :protocol option' do
-    @monkey = Monkey.new
-    @controller.absolute_url(:monkey,
-                             :id       => @monkey,
-                             :format   => :xml,
-                             :protocol => "https").should == "https://localhost/monkeys/45.xml"
-  end
-
-  it 'takes :host option' do
-    @monkey = Monkey.new
-    @controller.absolute_url(:monkey,
-                             :id       => @monkey,
-                             :format   => :xml,
-                             :protocol => "https",
-                             :host     => "rubyisnotrails.org").should == "https://rubyisnotrails.org/monkeys/45.xml"
-  end
-
-  it 'falls back to request protocol' do
-    @monkey = Monkey.new
-    @controller.absolute_url(:monkey,
-                             :id       => @monkey,
-                             :format   => :xml).should == "http://localhost/monkeys/45.xml"
-  end
-
-  it 'falls back to request host' do
-    @monkey = Monkey.new
-    @controller.absolute_url(:monkey,
-                             :id       => @monkey,
-                             :format   => :xml,
-                             :protocol => "https").should == "https://localhost/monkeys/45.xml"
-  end
-  
-  it "allows passing an object instead of a hash" do
-    @monkey = Monkey.new
-    @controller.absolute_url(:monkey, @monkey).should == "http://localhost/monkeys/45"
-  end
-  
-end