merb 0.4.0 → 0.4.1

data/spec/merb/handler_spec.rb

@@ -0,0 +1,169 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MerbHandler, "process" do
+  
+  def do_process
+    @handler.process( @request, @response )
+  end
+  
+  def log_info_with( with_param )
+    MERB_LOGGER.should_receive(:info).with( with_param )
+  end
+  
+  before(:each) do
+    @params = { Mongrel::Const::REQUEST_METHOD  => "GET",
+                Mongrel::Const::PATH_INFO       => "PUBLIC",
+                Mongrel::Const::REQUEST_URI     => "www.example.com/file" }
+                
+    
+    @static_file_handler = mock( "mongrel_dir_handler", :null_object => true )
+    @static_file_handler.stub!( :can_serve ).and_return( false )
+    Mongrel::DirHandler.stub!(:new).and_return( @static_file_handler ) # Need to get a handle on the dir handler in initialize
+    
+    @handler = MerbHandler.new( "public" )
+    
+    @response = mock( "response",  :null_object => true )
+    @response.stub!( :socket ).and_return( mock( "socket" ) )
+    @response.socket.stub!( :closed? ).and_return( false )
+    
+    @request = mock( "request",    :null_object => true )
+    @request.stub!( :params ).and_return( @params )
+
+    @benchmarks = { :setup_time => 1 }
+    @controller = mock( "controller", :null_object => true )
+    @controller.stub!(:class).and_return( "CONTROLLER_CLASS" )
+    @controller.stub!(:_benchmarks).and_return( @benchmarks )
+    @action = "ACTION"
+    Merb::Dispatcher.stub!( :handle ).and_return( [@controller, @action] )
+
+    MERB_LOGGER.stub!(:info)
+  end
+
+  it "should return nil if the socket is closed" do
+    @response.socket.stub!( :closed? ).and_return( true )
+    do_process.should be_nil
+  end
+  
+  it "should log the request URI to the MERB_LOGGER.info" do
+    log_info_with( /REQUEST_URI/ )
+    do_process
+  end
+  
+  
+  it "should serve static files" do
+    @static_file_handler.stub!( :can_serve ).and_return( true )
+    log_info_with( /static/i )
+    @static_file_handler.should_receive( :process ).with( @request, @response )
+    do_process
+  end
+  
+  it "should fall back to .html and try and serve the file" do
+    @static_file_handler.should_receive( :can_serve ).with( "PUBLIC.html" ).and_return( true )
+    @static_file_handler.should_receive( :process ).with( @request, @response )
+    log_info_with( /static/i )
+    do_process
+    @request.params[Mongrel::Const::PATH_INFO].should == "PUBLIC.html"
+  end
+  
+  it "should ask the Dispatcher for the controller and action" do
+    Merb::Dispatcher.should_receive( :handle ).with( @request, @response )
+    do_process
+  end
+  
+  it "should log any exceptions that reach the handler and return 500" do
+    @out = ""
+    @head = {}
+    Merb::Dispatcher.should_receive( :handle ).and_raise( Exception )
+    @response.should_receive( :send_status ).with( 500 )
+    MERB_LOGGER.should_receive(:error)
+    do_process
+  end
+  
+  it "should set the response.status to the controller.status" do
+    @controller.should_receive( :status ).and_return( "SPEC_STATUS" )
+    @response.should_receive( :status= ).with( "SPEC_STATUS" )
+    do_process
+  end
+  
+  it "should handle the X-SENDFILE header" do
+    @controller.should_receive( :headers ).and_return( { "X-SENDFILE" => __FILE__ } )
+    log_info_with( /X-SENDFILE/im )
+    @response.should_receive( :status= ).with( 200 )
+    @response.header.should_receive( :[]= ).with( Mongrel::Const::LAST_MODIFIED, an_instance_of( String ) )
+    @response.header.should_receive( :[]= ).with( Mongrel::Const::ETAG, anything() )
+    @response.should_recieve( :send_status ).with( File.size( __FILE__ ) )
+    @response.should_receive( :send_header )
+    @response.should_receive( :send_file )
+    
+    do_process
+  end
+  
+  it "should setup the headers" do
+    @response_header = {}
+    @controller.should_receive( :headers ).and_return( { "X-MY_HEADER" => "MY_HEADER_CONTENT" } )
+    @response.should_receive( :header ).and_return( @response_header )
+    @response_header.should_receive( :[]= ).with( "X-MY_HEADER", "MY_HEADER_CONTENT" )
+    do_process
+  end
+  
+  
+  it "should handle a controller body that can be read" do
+    # This is a bit dependent on implementation
+    @controller.should_receive( :headers ).and_return( { "CONTENT-LENGTH" => 5 } )
+    @body = Object.new
+    @body.stub!( :close ).and_return( true )
+    @body.stub!( :read ).and_return( false )
+    @body.should_receive( :read ).and_return( true, true, false )
+    @controller.stub!( :body ).and_return( @body )
+    @response.should_receive( :send_status ).with( 5 )
+    @response.should_receive( :send_header )
+    @response.should_receive( :write ).at_least( :once )
+    @body.should_receive( :close )
+    
+    do_process
+  end
+  
+  it "should handle a controller body that is a proc" do
+    @proc = Proc.new { "PROC_CONTENTS" }
+    @controller.should_receive( :body ).at_least(:once).and_return( @proc )
+    @proc.should_receive( :call )    
+    do_process
+  end
+  
+  it "should spit out a normal rendering of the controller" do
+    @body = "CONTROLLER_BODY"
+    @controller.stub!( :body ).and_return( @body )
+    @controller.should_receieve( :body ).at_least( :once ).and_return( @body )
+    
+    @response.should_receive( :send_status ).with( @body.length )
+    @response.should_receive( :send_header )
+    @response.should_receive( :write ).with( @body )
+    
+    do_process
+  end
+  
+  it "should log the controller and action called" do
+    log_info_with( /Routing to.+CONTROLLER_CLASS.+ACTION/ )
+    do_process
+  end
+  
+  it "should render the request times" do
+    log_info_with( /request times/i )
+    do_process
+  end
+  
+  it "should render the Response status" do
+    log_info_with( /response status/i )
+    do_process
+  end
+  
+  it "should remove path_prefix from the request_uri and path_info environment variables" do
+    MerbHandler.path_prefix = "/prefix"
+    @request.params[Mongrel::Const::PATH_INFO] = "/prefix/PUBLIC"
+    @request.params[Mongrel::Const::REQUEST_URI] = "/prefix/file"
+    do_process
+    @request.params[Mongrel::Const::PATH_INFO].should == "/PUBLIC"
+    @request.params[Mongrel::Const::REQUEST_URI].should == "/file"
+    MerbHandler.path_prefix = nil
+  end
+end

data/spec/merb/mail_controller_spec.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Merb
+  class MailController
+    self._template_root = File.expand_path(File.join(File.dirname(__FILE__), '..', "fixtures/mailers/views"))
+  end
+end
+Merb::Server.load_controller_template_path_cache
+
+class Merb::Mailer
+  self.delivery_method = :test_send
+end
+
+class TestMailController < Merb::MailController
+  
+  def first
+    render_mail
+  end
+  
+  def second
+    render_mail
+  end
+  
+  def third
+    render_mail :text => :first, :html => :third
+  end
+  
+  def fourth
+    render_mail :text => "FOURTH_TEXT", :html => "FOURTH_HTML"
+  end
+  
+  def fifth
+    render_mail :action => {:text => :first, :html => :third}
+  end
+  
+  def sixth
+    render_mail :action => {:text => :first}, :html => "SIXTH_HTML"
+  end
+  
+  def seventh
+    render_mail :text => :first, :html => "SEVENTH_HTML"
+  end
+  
+  def eighth
+    @testing = "TEST"
+    render_mail
+  end
+  
+  def ninth
+    render_mail
+  end
+  
+  def tenth
+    render_mail
+  end
+  
+end
+
+class TestController < Merb::Controller
+  
+  def one
+    send_mail TestMailController, :ninth, {:from => "foo@bar.com", :to => "foo@bar.com"}, {:x => "ONE_CONTROLLER"}
+  end
+  
+end
+
+describe "A Merb Mail controller" do
+  
+  def deliver(action)
+    TestMailController.dispatch_and_deliver action, :from => "foo@bar.com", :to => "foo@bar.com"
+    @delivery = Merb::Mailer.deliveries.last
+  end
+
+  undef :call_action if defined?(call_action)
+  def call_action(action)
+    @c = new_controller(action, TestController)
+    @c.dispatch(action)
+    @delivery = Merb::Mailer.deliveries.last  
+  end
+  
+  it "should render files in its directory by default" do
+    deliver :first
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+  end
+  
+  it "should render files in its directory without a mimetype extension by default" do
+    deliver :second
+    @delivery.text.should == "TEXT\nSECOND\nENDTEXT"
+  end
+  
+  it "should be able to accept a :text => :sym, :html => :sym render_mail" do
+    deliver :third
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "BASIC\nTHIRDHTML\nLAYOUT"
+  end
+  
+  it "should be able to accept a :text => STRING, :html => STRING render_mail" do
+    deliver :fourth
+    @delivery.text.should == "FOURTH_TEXT"
+    @delivery.html.should == "FOURTH_HTML"    
+  end
+  
+  it "should be able to accept an :action => {:text => :sym, :html => :sym}" do
+    deliver :fifth
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "BASIC\nTHIRDHTML\nLAYOUT"    
+  end
+  
+  it "should be able to accept a mix of action and :html => STRING" do
+    deliver :sixth
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "SIXTH_HTML"    
+  end
+  
+  it "should be able to accept a mix of :text => :sym and :html => STRING" do
+    deliver :seventh
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "SEVENTH_HTML"    
+  end
+  
+  it "should hold onto instance variables" do
+    deliver :eighth
+    @delivery.html.should == "BASIC\nTEST\nLAYOUT"    
+  end
+  
+  it "should have access to the params sent by the calling controller" do
+    @in = Merb::Test::FakeRequest.new
+    @res = StringIO.new    
+    call_action :one
+    @delivery.html.should == "BASIC\nONE_CONTROLLER\nLAYOUT"    
+  end
+  
+  it "should not raise an error if there are no templates" do
+    lambda do
+      deliver :tenth    
+    end.should_not raise_error
+  end
+  
+  it "should log an error if there are no templates available" do
+    MERB_LOGGER.should_receive(:error).once
+    deliver :tenth
+  end
+  
+end

data/spec/merb/mailer_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class TestMailer < Merb::Mailer
+  self.delivery_method = :test_send
+end
+
+class TestSMTPMailer < Merb::Mailer
+  self.delivery_method = :net_smtp
+  self.config = { :host     => 'smtp.yourserver.com',
+                  :port     => '25',              
+                  :user     => 'user',
+                  :pass     => 'pass',
+                  :auth     => :plain }
+                  
+end
+
+class TestSendmailMailer < Merb::Mailer
+  self.delivery_method = :sendmail
+end
+
+def setup_test_mailer klass = TestMailer
+  @m = klass.new :to      => "test@test.com",
+                 :from    => "foo@bar.com",
+                 :subject => "Test Subject",
+                 :body    => "Test"    
+end
+
+describe "a merb mailer" do
+  
+  it "should be able to send test emails" do
+    setup_test_mailer
+    @m.deliver!
+    TestMailer.deliveries.size.should == 1
+    delivery = TestMailer.deliveries.last
+    delivery.to.should include("test@test.com")
+    delivery.from.should include("foo@bar.com")
+    delivery.subject.should include("Test Subject")
+    delivery.body.should include("Test")
+  end
+  
+  it "should be able to accept attachments" do
+    setup_test_mailer
+    @m.attach File.open("README")
+    @m.deliver!
+    delivery = TestMailer.deliveries.last
+    delivery.instance_variable_get("@attachments").size.should == 1
+  end
+  
+  it "should be able to accept multiple attachments" do
+    setup_test_mailer
+    @m.attach [[File.open("README")], [File.open("LICENSE")]]
+    @m.deliver!
+    delivery = TestMailer.deliveries.last
+    delivery.instance_variable_get("@attachments").size.should == 2    
+  end
+  
+  it "should be able to send mails via SMTP" do
+    setup_test_mailer TestSMTPMailer
+    Net::SMTP.stub!(:start).and_return(true)
+    Net::SMTP.should_receive(:start).with("smtp.yourserver.com", 25, nil, "user", "pass", :plain)
+    @m.deliver!
+  end
+  
+  it "should send mails via SMTP with no auth" do
+    setup_test_mailer TestSMTPMailer
+    @m.config[:auth] = nil
+    Net::SMTP.stub!(:start).and_return(true)
+    Net::SMTP.should_receive(:start).with("smtp.yourserver.com", 25, nil, "user", "pass", nil)
+    @m.deliver!
+  end
+  
+  it "should be able to send mails via sendmail" do
+    sendmail = mock("/usr/sbin/sendmail", :null_object => true) 
+    setup_test_mailer TestSendmailMailer
+    IO.should_receive(:popen).with("/usr/sbin/sendmail #{@m.mail.to}", "w+").and_return(sendmail) 
+    @m.deliver!
+  end  
+  
+  it "should be able to use a different sendmail path" do 
+ 	  sendmail = mock("/somewhere/sendmail", :null_object => true) 
+ 	  setup_test_mailer TestSendmailMailer 
+ 	  @m.config[:sendmail_path] = '/somewhere/sendmail' 
+ 	  IO.should_receive(:popen).with("/somewhere/sendmail #{@m.mail.to}", "w+").and_return(sendmail) 
+ 	  @m.deliver! 
+ 	end
+  
+end

data/spec/merb/multipart_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Merb::Test::Multipart::Param, '.to_multipart' do
+  it "should represent the key and value correctly" do
+    param = Merb::Test::Multipart::Param.new('foo', 'bar')
+    param.to_multipart.should == %(Content-Disposition: form-data; name="foo"\r\n\r\nbar\r\n)
+  end
+end
+
+describe Merb::Test::Multipart::FileParam, '.to_multipart' do
+  it "should represent the key, filename and content correctly" do
+    param = Merb::Test::Multipart::FileParam.new('foo', '/bar.txt', 'baz')
+    param.to_multipart.should == %(Content-Disposition: form-data; name="foo"; filename="/bar.txt"\r\nContent-Type: text/plain\r\n\r\nbaz\r\n)
+  end
+end
+
+describe Merb::Test::Multipart::Post, '.push_params(params) param parsing' do
+  before(:each) do
+    @fake_return_param = mock('fake return_param')
+  end
+
+  it "should create Param from params when param doesn't respond to read" do
+    params = { 'normal' => 'normal_param' }
+    Merb::Test::Multipart::Param.should_receive(:new).with('normal', 'normal_param').and_return(@fake_return_param)
+    Merb::Test::Multipart::Post.new.push_params(params)
+  end
+  
+  it "should create FileParam from params when param does response to read" do
+    file_param = mock('file param')
+    file_param.should_receive(:read).and_return('file contents')
+    file_param.should_receive(:path).and_return('file.txt')
+    params = { 'file' => file_param }
+    Merb::Test::Multipart::FileParam.should_receive(:new).with('file', 'file.txt', 'file contents').and_return(@fake_return_param)
+    Merb::Test::Multipart::Post.new.push_params(params)
+  end
+end
+  
+describe Merb::Test::Multipart::Post, '.to_multipart' do
+  it "should create a multipart request from the params" do
+    file_param = mock('file param')
+    file_param.should_receive(:read).and_return('file contents')
+    file_param.should_receive(:path).and_return('file.txt')
+    params = { 'file' => file_param, 'normal' => 'normal_param' }
+    multipart = Merb::Test::Multipart::Post.new(params)
+    query, content_type = multipart.to_multipart
+    content_type.should == "multipart/form-data, boundary=----------0xKhTmLbOuNdArY"
+    query.should == "------------0xKhTmLbOuNdArY\r\nContent-Disposition: form-data; name=\"file\"; filename=\"file.txt\"\r\nContent-Type: text/plain\r\n\r\nfile contents\r\n------------0xKhTmLbOuNdArY\r\nContent-Disposition: form-data; name=\"normal\"\r\n\r\nnormal_param\r\n------------0xKhTmLbOuNdArY--"
+  end
+end

data/spec/merb/part_controller_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+Merb::Template::Erubis # Need to initialise the Erubis template
+
+class Main < Merb::Controller
+  
+  def index
+    part TodoPart => :list
+  end
+  
+  def index2
+    part TodoPart => :one
+  end
+  
+  def index3
+    part(TodoPart => :one) + part(TodoPart => :list)
+  end
+  
+  def index4
+    provides [:xml, :js]
+    part(TodoPart => :formatted_output)
+  end
+  
+end  
+
+
+class TodoPart < Merb::PartController
+  self._template_root = File.expand_path(File.join(File.dirname(__FILE__), '..', "fixtures/parts/views"))
+  
+  before :load_todos
+  
+  def list
+    render
+  end
+  
+  def one
+    render :layout => :none, :action => :list
+  end
+  
+  def load_todos
+    @todos = ["Do this", "Do that", 'Do the other thing']
+  end
+  
+  def formatted_output
+    render
+  end
+
+end
+
+describe "A Merb PartController" do
+  
+  before(:each) do
+    Merb::Router.prepare do |r|
+      r.default_routes
+    end
+  end  
+  
+  it "should render a part template with no layout" do
+    controller,action = request(:get, '/main/index2')
+    controller.body.should ==
+      "TODOPART\nDo this|Do that|Do the other thing\nTODOPART"
+  end
+  
+  it "should render a part template with it's own layout" do
+    controller,_ = request(:get, '/main/index')
+    controller.body.should ==
+      "TODOLAYOUT\nTODOPART\nDo this|Do that|Do the other thing\nTODOPART\nTODOLAYOUT"
+  end 
+  
+  it "should render multiple parts if more then one part is passed in" do
+    controller,_ = request(:get, '/main/index3')
+    controller.body.should ==
+      "TODOPART\nDo this|Do that|Do the other thing\nTODOPART" +
+      "TODOLAYOUT\nTODOPART\nDo this|Do that|Do the other thing\nTODOPART\nTODOLAYOUT"
+  end 
+  
+  it "should render the html format by default to the controller that set it" do
+    controller,_ = request(:get, '/main/index4')
+    controller.body.should match(/part_html_format/m)
+    
+  end
+  
+  it "should render the xml format according to the controller" do
+    controller,_ = request(:get, '/main/index4.xml')
+    controller.body.should match(/part_xml_format/m)
+  end
+
+  it "should render the xml format according to the controller" do
+    controller,_ = request(:get, '/main/index4.js')
+    controller.body.should match(/part_js_format/m)
+  end
+  
+end  

data/spec/merb/plugins_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Plugins", "default GENERATOR_SCOPE" do
+  it "should have :merb_default first" do
+    Merb::GENERATOR_SCOPE.first.should == :merb_default
+  end
+
+  it "should have :merb" do
+    Merb::GENERATOR_SCOPE.should include(:merb)
+  end
+
+  it "should have :rspec last" do
+    Merb::GENERATOR_SCOPE.last.should == :rspec
+  end
+end
+
+describe "Plugins","use_orm" do
+  before(:each) do
+    Merb::GENERATOR_SCOPE.replace [:merb_default, :merb, :rspec]    
+    Kernel.stub!(:dependency)
+  end
+  
+  it "should raise an error if use_orm is called twice" do
+    use_orm(:activerecord)
+    lambda { use_orm(:datamapper) }.should raise_error
+  end
+
+  it "should not have :merb_default in GENERATOR_SCOPE with use_orm(:activerecord)" do
+    use_orm(:activerecord)
+    Merb::GENERATOR_SCOPE.should_not include(:merb_default)
+  end
+
+  it "should have :activerecord in GENERATOR_SCOPE with use_orm(:activerecord)" do
+    use_orm(:activerecord)
+    Merb::GENERATOR_SCOPE.should include(:activerecord)
+  end
+
+  it "should have :activerecord first in GENERATOR_SCOPE with use_orm(:activerecord)" do
+    use_orm(:activerecord)
+    Merb::GENERATOR_SCOPE.first.should == :activerecord
+  end
+  
+  it "should call dependency :merb_activerecord with use_orm(:activerecord)" do
+    Kernel.should_receive(:dependency).with("merb_activerecord").once.
+      and_return(true)
+    use_orm(:activerecord)
+  end
+  
+end
+
+describe "Plugins","use_test" do
+  before(:each) do
+    Merb::GENERATOR_SCOPE.replace [:merb_default, :merb, :rspec]    
+  end
+  
+  it "should have :rspec in GENERATOR_SCOPE by default" do
+    Merb::GENERATOR_SCOPE.should include(:rspec)
+  end
+
+  it "should not have :rspec in GENERATOR_SCOPE with use_test(:test_unit)" do
+    use_test(:test_unit)
+    Merb::GENERATOR_SCOPE.should_not include(:rspec)
+  end
+
+  it "should have :test_unit in GENERATOR_SCOPE with use_test(:test_unit)" do
+    use_test(:test_unit)
+    Merb::GENERATOR_SCOPE.should include(:test_unit)
+  end
+
+  it "should have :test_unit last in GENERATOR_SCOPE with use_test(:test_unit)" do
+    use_test(:test_unit)
+    Merb::GENERATOR_SCOPE.last.should == :test_unit
+  end
+  
+  it "should raise an error if called with an unsupported test framework" do
+    lambda { use_test(:fiddlefaddle) }.should raise_error
+  end
+  
+  it "should allow adding more than test_unit or rspec via plugins"
+end