merb 0.5.3 → 0.9.2

data/spec/merb/fake_request_spec.rb

@@ -1,80 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Merb::Test::FakeRequest, ".new(env = {}, method = 'GET', req = StringIO.new)" do
-  it "should create request with default enviroment" do
-    @mock = Merb::Test::FakeRequest.new
-    @mock.env.should == Merb::Test::FakeRequest::DEFAULT_ENV
-  end
-  
-  it "should override default env values passed in HTTP format" do
-    @mock = Merb::Test::FakeRequest.new('HTTP_ACCEPT' => 'nothing')
-    @mock['HTTP_ACCEPT'].should == 'nothing'
-  end
-  
-  it "should override default env values passed in symbol format" do
-    @mock = Merb::Test::FakeRequest.new(:http_accept => 'nothing')
-    @mock['HTTP_ACCEPT'].should == 'nothing'
-  end
-  
-  it "should change :cookies into HTTP_COOKIE" do
-    @mock = Merb::Test::FakeRequest.new(:cookies => 'icanhazcookie=true')
-    @mock['HTTP_COOKIE'].should == 'icanhazcookie=true'
-  end
-  
-  it "should set body to an empty StringIO" do
-    @mock = Merb::Test::FakeRequest.new
-    @mock.body.should be_kind_of(StringIO)
-    @mock.body.read.should == ''
-  end 
-end
-
-describe Merb::Test::FakeRequest, ".with(path, options = {})" do
-  before(:each) do
-    @mock = Merb::Test::FakeRequest.with('/foo?bar=baz') 
-  end
-  
-  it "should set REQUEST_URI to path" do
-    @mock['REQUEST_URI'].should == '/foo?bar=baz'
-  end
-  
-  it "should set PATH_INFO to path without query string" do
-    @mock['PATH_INFO'].should == '/foo'
-  end
-  
-  it "should pass other options through to new" do
-    @mock = Merb::Test::FakeRequest.with('/foo?bar=baz', :http_accept => 'cash/money')
-    @mock['HTTP_ACCEPT'].should == 'cash/money' 
-  end
-end
-
-describe Merb::Test::FakeRequest, ".post_body=(post)" do
-  it "should wrap post param in new StringIO" do
-    @mock = Merb::Test::FakeRequest.new
-    @mock.post_body = "hello world"
-    @mock.body.should be_kind_of(StringIO)
-    @mock.body.read.should == "hello world"
-  end
-end
-
-describe Merb::Test::FakeRequest, "[](key)" do
-  it "should return the key from @env" do
-    @mock = Merb::Test::FakeRequest.new(:http_accept => 'cash/money')
-    @mock['HTTP_ACCEPT'].should == 'cash/money' 
-  end
-end
-
-describe Merb::Test::FakeRequest, "[]=(key, value)" do
-  it "should set key in @env to value" do
-    @mock = Merb::Test::FakeRequest.new(:http_accept => 'cash/money')
-    @mock['HTTP_ACCEPT'] = 'also/credit_card'
-    @mock['HTTP_ACCEPT'].should == 'also/credit_card'     
-  end
-end
-
-describe Merb::Test::FakeRequest, "session" do
-  it "should have a memory-based session" do
-    @mock = Merb::Test::FakeRequest.new
-    @mock.session[:random] = "random"
-    @mock.session[:random].should == "random"
-  end
-end

data/spec/merb/generator_spec.rb

@@ -1,248 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_generator_helper'
-
-
-describe "an app generator" do
-  include RubiGen::GeneratorTestHelper
-
-  before :all do
-    module Kernel
-      alias_method :old_dependency, :dependency
-      undef dependency
-    end  
-  end
-
-  after :all do
-    module Kernel
-      alias_method :dependency, :old_dependency
-    end  
-  end
-
-  before do
-    @generator =  build_generator('merb', [APP_ROOT], sources, {})
-  end
-  
-  after do
-    bare_teardown  # Cleans up the temporary application directory that gets created as part of the test.
-  end
-
-  it "should be get created" do
-    @generator.should_not be_nil
-  end
-  
-  it "should be a MerbGenerator" do
-    @generator.should be_an_instance_of(MerbGenerator)
-  end
-  
-  it "should create directory structure" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      app
-      app/controllers
-      app/helpers
-      app/mailers
-      app/mailers/helpers
-      app/mailers/views/layout
-      app/mailers/views
-      app/models
-      app/views
-      app/views/layout
-      config
-      config/environments
-      lib
-      log
-      public
-      public/images
-      public/javascripts
-      public/stylesheets
-      script
-      test
-    }.each{|dir| directory_should_be_created(dir)}    
-  end
-    
-  it "should create files from templates" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      app/controllers/application.rb
-      app/helpers/global_helper.rb
-      app/mailers/views/layout/application.html.erb
-      app/views/layout/application.html.erb
-      config/environments/development.rb
-      config/environments/production.rb
-      config/environments/test.rb
-      config/merb.yml
-      config/merb_init.rb
-      config/router.rb
-      config/dependencies.rb
-      config/upload.conf
-      Rakefile
-      script/stop_merb
-      script/generate
-      script/destroy
-    }.each{|file| file_should_be_created(file)}
-  end
-  
-  it "should create files from rubigen dependency" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      script/generate
-      script/destroy
-    }.each{|file| file_should_be_created(file)}
-  end
-  
-  it "should make script files executable" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    
-    %w{
-      script/stop_merb
-      script/generate
-      script/destroy
-    }.each{|file| file_should_be_executable(file)}
-  end
-  
-  def sources
-    [RubiGen::PathSource.new(:test, File.join(File.dirname(__FILE__),"../../", generator_path))
-    ]
-  end
-  
-  def generator_path
-    "app_generators"
-  end
-  
-end
-
-describe "a controller generator" do
-  include RubiGen::GeneratorTestHelper
-
-  before :all do
-    module Kernel
-      alias_method :old_dependency, :dependency
-      undef dependency
-    end  
-  end
-
-  after :all do
-    module Kernel
-      alias_method :dependency, :old_dependency
-    end  
-  end
-
-  before do
-    @generator =  build_generator('controller', ["my_posts"], sources, {})
-  end
-
-  after do
-    bare_teardown  # Cleans up the temporary application directory that gets created as part of the test.
-  end
-
-  it "should be get created" do
-    @generator.should_not be_nil
-  end
-
-  it "should be a ControllerGenerator" do
-    @generator.should be_an_instance_of(ControllerGenerator)
-  end
-
-  it "should create directory structure" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      app
-      app/controllers
-      app/helpers
-      app/views
-      app/views/my_posts
-    }.each{|dir| directory_should_be_created(dir)}    
-  end
-
-  it "should create files from templates" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      app/controllers/my_posts.rb
-      app/helpers/my_posts_helper.rb
-      app/views/my_posts/index.html.erb
-    }.each{|file| file_should_be_created(file)}
-  end
-
-  def sources
-    [
-      RubiGen::PathSource.new(:app, File.join(File.dirname(__FILE__),"../../", "merb_generators")),
-      RubiGen::PathSource.new(:app, File.join(File.dirname(__FILE__),"../../", "rspec_generators"))
-    ]
-  end
-end
-
-describe "a part_controller generator" do
-  include RubiGen::GeneratorTestHelper
-
-  before :all do
-    module Kernel
-      alias_method :old_dependency, :dependency
-      undef dependency
-    end  
-  end
-
-  after :all do
-    module Kernel
-      alias_method :dependency, :old_dependency
-    end  
-  end
-
-  before do
-    @generator =  build_generator('part_controller', ["my_posts"], sources, {})
-  end
-
-  after do
-    bare_teardown  # Cleans up the temporary application directory that gets created as part of the test.
-  end
-
-  it "should be get created" do
-    @generator.should_not be_nil
-  end
-
-  it "should be a PartControllerGenerator" do
-    @generator.should be_an_instance_of(PartControllerGenerator)
-  end
-
-  it "should create directory structure" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      app
-      app/parts/controllers
-      app/parts/helpers
-      app/parts/views
-      app/parts/views/my_posts_part
-    }.each{|dir| directory_should_be_created(dir)}    
-  end
-
-  it "should create files from templates" do
-    silence_generator do
-      @generator.command(:create).invoke!
-    end
-    %w{
-      app/parts/controllers/my_posts_part.rb
-      app/parts/helpers/my_posts_part_helper.rb
-      app/parts/views/my_posts_part/index.html.erb
-    }.each{|file| file_should_be_created(file)}
-  end
-
-  def sources
-    [
-      RubiGen::PathSource.new(:app, File.join(File.dirname(__FILE__),"../../", "merb_generators")),
-      RubiGen::PathSource.new(:app, File.join(File.dirname(__FILE__),"../../", "rspec_generators"))
-    ]
-  end
-end

data/spec/merb/handler_spec.rb

@@ -1,169 +0,0 @@
-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 ).and_return( [@controller, @action] )
-    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