merb 0.4.0 → 0.4.1

data/spec/merb/render_spec.rb

@@ -0,0 +1,378 @@
+require 'stringio'
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/controllers/render_spec_controllers'
+
+describe "rendering engines except XMLBuilder", :shared => true do
+  it "should render a template" do
+    c = new_controller
+    content = c.render :template => "#{@engine}", :layout => :none
+    content.clean.should == "Hello!"
+  end
+
+  it "should render a partial" do
+    c = new_controller
+    content = c.partial "partials/#{@engine}"
+    content.clean.should == "No Locals!"
+  end
+
+  it "should render a partial with locals" do
+    c = new_controller
+    content = c.partial "partials/#{@engine}", :yo => "Locals!"
+    content.clean.should == "Locals!"
+  end
+
+  it "should render a partial using the :partial method" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}")
+    content.clean.should == "No Locals!"
+  end
+
+  it "should render a partial using the :partial method with locals" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}", :yo => "Locals!")
+    content.clean.should == "Locals!"
+  end
+
+  it "should render a partial iterating over a collection" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}_collection",
+      :with => (1..10).to_a)
+    content.clean.should == (1..10).to_a.join("\n")
+  end
+
+  it "should render a partial with an object" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}_collection", :with => 1)
+    content.clean.should == '1'
+  end
+
+  it "should allow you to overwrite the local var using :as when rendering a collection" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}_collection_with_locals", :with => (1..10).to_a, :as => :number)
+    content.clean.should == (1..10).to_a.join("\n")
+  end
+
+  it "should allow you to overwrite the local var using :as when render an object" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}_collection_with_locals", :with => 1, :as => :number)
+    content.clean.should == '1'
+  end
+
+  it "should render a partial iterating over a collection with extra locals" do
+    c = new_controller
+    content = c.partial("partials/#{@engine}_collection_with_locals", :with => (1..10).to_a, :number => 'Locals!')
+    content.clean.should == (1..10).to_a.map { |i| "Locals!" }.join("\n")
+  end
+
+  it "should render a partial using the .format.engine convention" do
+    c = new_controller
+    content = c.partial "partials/#{@engine}_new"
+    content.clean.should == "No Locals!"
+  end
+  
+  it "should render a template without a layout" do
+    c = new_controller
+    content = c.render_no_layout(:template => "#{@engine}")
+    content.clean.should == "Hello!"
+  end
+
+  it "should raise an exception without a template" do
+    c = new_controller(nil, Examples)
+    lambda {
+      c.render_no_layout(:template => nil)
+    }.should raise_error(Merb::ControllerExceptions::TemplateNotFound)
+  end
+
+  it "should find a snake case partial" do
+    c = new_controller(nil, Examples)
+    content = c.partial("#{@engine}")
+    content.clean.should == "Hello!"
+  end
+
+  it "should implement a _buffer method" do
+    c = new_controller
+    content = c.render :template => "template_views/interface__buffer_#{@engine}", :layout => :none
+    content.should match( /respond_to\?\(\s*\:_buffer\s*\)\s+\=\s+TRUE/ )
+    content.should match( /Text for the view buffer/ )
+  end
+      
+  it "should implement a concat( text, binding ) method" do
+    c = new_controller
+    content = c.render :template => "template_views/interface_concat_#{@engine}", :layout => :none
+    content.should match( /Concat Text/ )
+  end
+
+  it "should bind the concat to a block" do
+    c = new_controller
+    content = c.render :template => "template_views/interface_concat_#{@engine}", :layout => :none
+    content.should match( /Start Tester Block\s*In Tester Block\s*Finish Tester Block/m)
+  end
+
+  it "should implement a capture( &block ) method" do
+    c = new_controller
+    content = c.render :template => "template_views/interface_capture_#{@engine}", :layout => :none
+    content.should match( /Capture Text Without Args/m)
+  end
+  
+  it "should render #{@engine} partial using .format.engine convention#{" (caching on)" if defined?(cache) && cache}" do
+    c = new_controller
+    content = c.partial "partials/#{@engine}_new"
+    content.clean.should == "No Locals!"
+  end
+
+  # # These cannot be implemented at this stage with Markaby without instance_exec which will
+  # # not be available until Ruby 1.9
+  # it "should implement capture and yield arguments to the block for #{@engine}" do
+  #   c = new_controller
+  #   content = c.render :template => "template_views/interface_capture_#{@engine}", :layout => :none
+  #   content.should match( /capture text from yielded object/im)
+  # end
+  #
+  # # This cannot be specced until Ruby 1.9 is available due to instance_exec
+  # # unless markaby can be made to accept arguments for this method.
+  # it "should capture content in a block for #{@engine}" do
+  #   c = new_controller
+  #   content = c.render :template => "template_views/interface_capture_#{@engine}", :layout => :none
+  #   content.should match( /BEFORE\s*capture text from yielded object\s*AFTER/im)
+  # end
+end
+
+[true, false].each do |cache|
+  Merb::Server.config[:cache_templates] = cache
+
+  describe "Merb rendering in general#{" (caching enabled)" if cache}" do
+    it "should render inline with Erubis" do
+      c = new_controller
+      content = c.render :inline => "<%= 'Inline' %>", :layout => :none
+      content.clean.should == "Inline"
+    end
+
+    it "should render an XML string" do
+      c = new_controller(nil, Examples)
+      content = c.render :xml => "<hello>world</hello>"
+      content.clean.should == "<hello>world</hello>"
+      c.headers["Content-Type"].should == "application/xml"
+      c.headers["Encoding"].should == "UTF-8"
+    end
+
+    it "should render a javascript string" do
+      c = new_controller(nil, Examples)
+      content = c.render(:js => "alert('Hello, world!');")
+      content.clean.should == %{alert('Hello, world!');}
+    end
+
+    it "should raise an TemplateNotFound error if a template is called that does not exist" do
+      c = new_controller(nil, Examples)
+      lambda do
+        c.render(:template => "does_not_exist", :format => :html)
+      end.should raise_error(Merb::ControllerExceptions::TemplateNotFound)      
+    end
+    
+    it "should render a template from a directory with a . in it's path" do
+      c = new_controller(nil, Examples)
+      lambda do
+        c.render(:template => "test.dir/the_template", :format => :html)
+      end.should_not raise_error(Merb::ControllerExceptions::TemplateNotFound)
+    end
+    
+  end
+
+  describe "Merb rendering with the Erubis engine#{" (caching enabled)" if cache}" do
+    before(:all) { @engine = "erubis" }
+    it_should_behave_like "rendering engines except XMLBuilder"
+
+    it "should render a nested controller's views" do
+      c = new_controller(nil, Nested::Example)
+      content = c.render(:action => "test")
+      content.clean.should == "Hello!"
+    end
+
+    it "should report the selected template in controller._template" do
+      c = new_controller
+      content = c.render(:template => "erubis")
+      c.template.should == "erubis.html.erb"
+    end
+
+    it "should raise LayoutNotFound if the layout is missing" do
+      c = new_controller
+      lambda {
+        c.render(:template => "erubis", :layout => "this_is_not_a_layout")
+      }.should raise_error(Merb::ControllerExceptions::LayoutNotFound)
+    end
+
+    it "should render the index action using index.html.erb" do
+      c = new_spec_controller
+      c.dispatch(:index)
+      c.template.should == "index.html.erb"
+    end
+
+    it "should render an erubis .html.erb template" do
+      c = new_spec_controller(:format => 'html')
+      c.dispatch(:erubis_templates)
+      c.template.should == "erubis_templates.html.erb"
+    end
+
+    it "should render an .html.erb template in front of a erubis_templates.rhtml" do
+      c = new_spec_controller(:format => 'html')
+      c.dispatch(:erubis_templates)
+      c.template.should == "erubis_templates.html.erb"
+    end
+
+    it "should render an erubis .js.erb template" do
+      c = new_spec_controller(:format => 'js')
+      c.dispatch(:erubis_templates)
+      c.template.should == "erubis_templates.js.erb"
+    end
+
+    it "should render an erubis .xml.erb template" do
+      c = new_spec_controller(:format => 'xml')
+      c.dispatch(:erubis_templates)
+      c.template.should == "erubis_templates.xml.erb"
+    end
+    
+    it "should render js in nested partials when the format is javascript" do
+      c = new_spec_controller
+      c.dispatch(:render_nested_js)      
+      c.body.should match(/nested_js_partial/m)
+    end
+    
+    it "should render xml in nested partials when the format is xml" do
+      c = new_spec_controller
+      c.dispatch(:render_nested_xml)      
+      c.body.should match(/nested_xml_partial/m)
+    end
+    
+    it "should render multiple partials with locals" do
+      c = new_spec_controller(:controller => "ExtensionTemplateController")
+      c.dispatch(:render_multiple_partials)
+      (1..10).each do |i|
+        c.body.should match(/#{i}/)
+      end    
+    end
+
+  end
+
+  describe "Merb rendering with the Markaby engine#{" (caching enabled)" if cache}" do
+    before(:all) { @engine = "markaby" }
+    it_should_behave_like "rendering engines except XMLBuilder"
+
+    it "should render markaby_index using markaby_index.html.mab" do
+      c = new_spec_controller
+      c.dispatch(:markaby_index)
+      c.template.should == "markaby_index.html.mab"
+    end
+
+    it "should render a markaby .html.mab template" do
+      c = new_spec_controller(:format => 'html')
+      c.dispatch(:markaby_templates)
+      c.template.should == "markaby_templates.html.mab"
+    end
+
+    it "should render a markaby .js.mab template" do
+      c = new_spec_controller(:format => 'js')
+      c.dispatch(:markaby_templates)
+      c.template.should == "markaby_templates.js.mab"
+    end
+
+    it "should render a markaby .xml.mab template" do
+      c = new_spec_controller(:format => 'xml')
+      c.dispatch(:markaby_templates)
+      c.template.should == "markaby_templates.xml.mab"
+    end
+  end
+
+  # XMLBuilder and Haml templates aren't supported under JRuby yet
+  unless RUBY_PLATFORM =~ /java/
+    describe "Merb rendering with the Haml engine#{" (caching enabled)" if cache}" do
+      before(:all) { @engine = "haml" }
+      it_should_behave_like "rendering engines except XMLBuilder"
+
+      it "should render haml_index using haml_index.html.haml" do
+        c = new_spec_controller
+        c.dispatch(:haml_index)
+        c.template.should == "haml_index.html.haml"
+      end
+
+      it "should render an haml .html.haml template" do
+        c = new_spec_controller(:format => 'html')
+        c.dispatch(:haml_templates)
+        c.template.should == "haml_templates.html.haml"
+      end
+
+      it "should render an haml .js.haml template" do
+        c = new_spec_controller(:format => 'js')
+        c.dispatch(:haml_templates)
+        c.template.should == "haml_templates.js.haml"
+      end
+
+      it "should render an haml .xml.haml template" do
+        c = new_spec_controller(:format => 'xml')
+        c.dispatch(:haml_templates)
+        c.template.should == "haml_templates.xml.haml"
+      end
+
+    end
+
+    describe "Merb rendering with the XMLBuilder engine#{" (caching enabled)" if cache}" do
+      before(:all) { @engine = "builder" }
+
+      it "should render an XML template from a symbol" do
+        c = new_controller(nil, Examples)
+        content = c.render :xml => :hello
+        content.clean.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<hello>world</hello>"
+        c.headers["Content-Type"].should == "application/xml"
+      end
+
+      it "should render an XML template from an action" do
+        c = new_controller(nil, Examples)
+        content = c.render :xml => true, :action => "hello"
+        content.clean.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<hello>world</hello>"
+        c.headers["Content-Type"].should == "application/xml"
+      end
+
+    end
+  end
+
+end
+
+describe "Merb rendering with an object calls to_json or to_xml on the object" do
+  it "render @foo should call @foo.to_json when json is requested" do
+      c = new_spec_controller(:format => 'json', :controller => 'RenderObjectController')
+      c.dispatch(:render_object)
+      c.body.should == "{'foo':'bar'}"
+  end
+  
+  it "render @foo should call @foo.to_xml when json is requested" do
+      c = new_spec_controller(:format => 'xml', :controller => 'RenderObjectController')
+      c.dispatch(:render_object)
+      c.body.should == "<foo>bar</foo>" 
+  end
+  
+  it "should render the template for the action when called with an object and the template exists" do
+    c = new_spec_controller(:format => :html, :controller => 'RenderObjectController')
+    c.dispatch(:render_object_with_template)
+    c.body.should match(/object with template html format/)
+  end
+  
+  it "should render the template for the action when called with an object and the template exists" do
+    c = new_spec_controller(:format => :xml, :controller => 'RenderObjectController')
+    c.dispatch(:render_object_with_template)
+    c.body.should match(/object with template xml format/)
+  end
+  
+  it "should render the template for the action when called with an object and the template exists" do
+    c = new_spec_controller(:format => :js, :controller => 'RenderObjectController')
+    c.dispatch(:render_object_with_template)
+    c.body.should match(/object with template js format/)
+  end
+  
+end
+
+def new_spec_controller(options={})
+  params = {:controller => 'ExtensionTemplateController'}
+  params.update(:format => options.delete(:format)) if options[:format]
+  params.update(:controller => options[:controller]) if options[:controller]
+  @request = Merb::Test::FakeRequest.new(options)
+  @request.params.merge!(params)
+  Object.const_get(params[:controller].to_sym).build(@request, @request.body)
+end

data/spec/merb/request_spec.rb

@@ -0,0 +1,243 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Merb::Request do
+  include Mocha::SetupAndTeardown
+  
+  class GoodPosts < Merb::Controller
+    def show() end
+  end
+  
+  before(:each) do
+    setup_stubs
+    @in = Merb::Test::FakeRequest.new
+    Merb::Request.any_instance.stubs(:route_params).returns({})
+  end
+  
+  after(:each) do
+    teardown_stubs
+  end
+  
+  it "should parse POST body into params" do
+    @in.post_body = "title=hello%20there&body=some%20text&user[roles][]=admin&user[roles][]=superuser&commit=Submit"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.params[:title].should == "hello there"
+    request.params[:body].should == "some text"
+    request.params[:commit].should == "Submit"
+    request.params[:user][:roles].class.should == Array
+    request.params[:user][:roles][0].should == "admin"
+    request.params[:user][:roles][1].should == "superuser"
+  end
+  
+  it "should parse POST body into params unless Content-Type header is set explicitly" do
+    input = "title=hello%20there&body=some%20text&commit=Submit"
+    @in.post_body = input
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = 'text/plain'
+    request = Merb::Request.new(@in)
+    request.params[:title].should be_nil
+    request.params[:body].should be_nil
+    request.params[:commit].should be_nil
+    request.raw_post.should == input
+  end
+  
+  it "should parse PUT body into params" do
+    @in.post_body = "title=hello%20there&body=some%20text&commit=Submit"
+    @in['REQUEST_METHOD'] = 'PUT'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.params[:title].should == "hello there"
+    request.params[:body].should == "some text"
+    request.params[:commit].should == "Submit"
+  end
+  
+  it "should parse PUT body into params unless Content-Type header is set explicitly" do
+    input = "title=hello%20there&body=some%20text&commit=Submit"
+    @in.post_body = input
+    @in['REQUEST_METHOD'] = 'PUT'
+    @in['CONTENT_TYPE'] = 'text/plain'
+    request = Merb::Request.new(@in)
+    request.params[:title].should be_nil
+    request.params[:body].should be_nil
+    request.params[:commit].should be_nil
+    request.raw_post.should == input
+  end
+    
+  it "should parse Query String into params" do
+    @in['QUERY_STRING'] = "title=hello%20there&body=some%20text&commit=Submit"
+    request = Merb::Request.new(@in)
+    request.params[:title].should == "hello there"
+    request.params[:body].should == "some text"
+    request.params[:commit].should == "Submit"
+  end
+  
+  it "shouldn't explode on key only query" do
+    @in['QUERY_STRING'] = "pop"
+    request = Merb::Request.new(@in)
+    request.params.has_key?(:pop).should be_true
+  end
+  
+  it "shouldn't explode on value only query" do
+    @in['QUERY_STRING'] = "=bang"
+    request = Merb::Request.new(@in)
+    request.params.has_value?('bang').should be_true
+  end
+  
+  it "should handle file upload for multipart/form-data posts" do
+    m = Merb::Test::Multipart::Post.new :file => File.open(FIXTURES / 'sample.txt')
+    body, head = m.to_multipart
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = head
+    @in['CONTENT_LENGTH'] = body.length
+    @in.post_body = body
+    request = Merb::Request.new(@in)
+    request.params[:file].should_not be_nil
+    request.params[:file][:tempfile].class.should == Tempfile
+    request.params[:file][:content_type].should == 'text/plain'
+  end
+  
+  # it "multipart/form-data handles multiple form fields" do
+  #   m = Merb::Test::Multipart::Post.new :foo => 'bario', 'files[]' => File.open(FIXTURES / 'sample.txt')
+  #   m.push_params 'files[]' => File.open(FIXTURES / 'foo.rb') 
+  #   body, head = m.to_multipart
+  #   @in['REQUEST_METHOD'] = 'POST'
+  #   @in['CONTENT_TYPE'] = head
+  #   @in['CONTENT_LENGTH'] = body.length
+  #   @in.post_body = body
+  #   request = Merb::Request.new(@in)
+  #   params[:foo].should == 'bario'
+  #   params[:files].should_not be_nil
+  #   params[:files].should be_kind_of(Array)
+  #   params[:files].first[:tempfile].class.should == Tempfile
+  # end
+  
+  it "Json Post Body is parsed into params" do
+    @in.post_body = "{\"title\":\"hello there\",\"body\":\"some text\"}"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "text/x-json"
+    request = Merb::Request.new(@in)
+    request.params[:title].should == "hello there"
+    request.params[:body].should == "some text"
+  end
+  
+  it "Json Post Body is not parsed into params if Merb::Request::parse_json_params = false" do
+    Merb::Request::parse_json_params = false
+    @in.post_body = "{\"title\":\"hello there\",\"body\":\"some text\"}"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "text/x-json"
+    request = Merb::Request.new(@in)
+    request.params[:title].should be_nil
+    request.params[:body].should be_nil
+    Merb::Request::parse_json_params = true
+  end
+  
+  it "should handle hash-style form fields in multipart/form-data" do
+    m = Merb::Test::Multipart::Post.new :foo => 'bario',
+         'files[foo][file]' => File.open(FIXTURES / 'foo.rb'),
+         'files[foo][name]' => "Foo",
+         'files[bar][file]' => File.open(FIXTURES / 'foo.rb'),
+         'files[bar][name]' => "Bar",
+         'deep[files][foobar][]' => File.open(FIXTURES / 'foo.rb'),
+         'regular_fields[user][name]' => "John Doe",
+         'regular_fields[user][email]' => "jdoe@example.com"
+    body, head = m.to_multipart
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = head
+    @in['CONTENT_LENGTH'] = body.length
+    @in.post_body = body
+    request = Merb::Request.new(@in)
+    
+    request.params.should_not include(:"files[foo]")
+    request.params.should_not include(:"files[bar]")
+    request.params.should_not include(:"regular_fields[user]")
+    request.params.should_not include(:"deep[files]")
+    
+    request.params[:files][:foo][:name].should == "Foo"
+    request.params[:files][:foo][:file].should include(:filename)
+    request.params[:files][:foo][:file][:tempfile].class.should == Tempfile
+    request.params[:files][:bar][:name].should == "Bar"
+    request.params[:files][:bar][:file].should include(:filename)
+    request.params[:files][:bar][:file][:tempfile].class.should == Tempfile
+    
+    request.params[:deep][:files][:foobar].class.should == Array
+    request.params[:deep][:files][:foobar].size.should == 1
+    
+    request.params[:regular_fields][:user][:name].should == "John Doe"
+  end
+  
+  it "should understand PUT if passed as _method in query string for RESTful form dispatch" do
+    @in.post_body = "title=hello"
+    @in['QUERY_STRING'] = '_method=put'
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.method.should == :put
+    request.params[:title].should == "hello"
+  end
+
+  it "should understand DELETE if passed as _method in query string for RESTful form dispatch" do
+    @in.post_body = "title=hello"
+    @in['QUERY_STRING'] = '_method=delete'
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)    
+    request.method.should == :delete
+    request.params[:title].should == "hello"
+  end
+  
+  it "should understand PUT if passed as _method in request body for RESTful form dispatch" do
+    @in.post_body = "_method=put&title=hello"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.method.should == :put
+    request.params[:title].should == "hello"
+  end
+
+  it "should understand DELETE if passed as _method in request body for RESTful form dispatch" do
+    @in.post_body = "_method=delete&title=hello"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.env['REQUEST_METHOD'].should == 'POST'
+    request.method.should == :delete
+    request.params[:title].should == "hello"
+  end
+
+  it "should not raise a NotFound exception when the controller class exists" do
+    @in['REQUEST_URI'] = "/good_posts/show/1"
+    @in['REQUEST_METHOD'] = 'GET'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.stubs(:controller_name).returns("good_posts")
+    lambda { request.controller_class }.should_not raise_error(Merb::ControllerExceptions::NotFound)
+  end
+  
+  it "should raise a NotFound exception when the controller does not exist" do
+    @in['REQUEST_URI'] = "/bad_posts/show/1"
+    @in['REQUEST_METHOD'] = 'GET'
+    @in['CONTENT_TYPE'] = "application/x-www-form-urlencoded"
+    request = Merb::Request.new(@in)
+    request.stubs(:controller_name).returns("bad_posts")
+    lambda { request.controller_class }.should raise_error(Merb::ControllerExceptions::NotFound)
+  end
+
+  it "should set accept to '*/*' when HTTP_ACCEPT is blank" do
+    @in['HTTP_ACCEPT'] = ""
+    request = Merb::Request.new(@in)
+    request.accept.should == "*/*"
+  end
+
+  it "should set accept to '*/*' when HTTP_ACCEPT is empty" do
+    @in['HTTP_ACCEPT'] = nil
+    request = Merb::Request.new(@in)
+    request.accept.should == "*/*"
+  end
+
+  it "should set accept to '*/*' when HTTP_ACCEPT is not set" do
+    @in.env.delete('HTTP_ACCEPT')
+    request = Merb::Request.new(@in)
+    request.accept.should == "*/*"
+  end
+end