merb-core 0.9.7 → 0.9.8

data/spec/public/reloading/reload_spec.rb

@@ -1,103 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-
-class MockTimedExecutor
-  def self.every(seconds, &block)
-    @@scheduled_action = block
-  end
-  def self.run_task
-    @@scheduled_action.call 
-  end
-end
-
-RealTimedExecutor = Merb::BootLoader::ReloadClasses::TimedExecutor
-Merb::BootLoader::ReloadClasses::TimedExecutor = MockTimedExecutor
-
-Merb.start :environment => 'test',
-           :merb_root => File.dirname(__FILE__) / "directory"
-
-describe "TimedExecutor" do
-  it "should call a block of code repeatedly in the background" do
-    list_of_things = []
-    
-    RealTimedExecutor.every(0.1) do
-      list_of_things << "Something"
-    end
-    
-    sleep 0.5
-    
-    list_of_things.should_not be_empty
-    list_of_things.size.should > 1
-  end
-  
-end
-
-describe "The reloader" do
-
-  before :all do
-    @reload_file = File.dirname(__FILE__) / "directory" / "app" / "controllers" / "reload.rb"
-    @text =  <<-END
-
-        class Reloader < Application
-        end
-
-        class Hello < Application
-        end
-      END
-     update_file @text
-     MockTimedExecutor.run_task
-  end
-
-  def update_file(contents)
-    mtime = File.mtime(@reload_file)
-    f = File.open(@reload_file, "w") do |f|
-      f.puts contents
-    end
-    File.utime(mtime+30, mtime+30, @reload_file)
-  end
-
-  it "should reload files that were changed" do
-    defined?(Hello).should_not be_nil
-    defined?(Reloader).should_not be_nil
-    defined?(Reloader2).should be_nil
-
-    update_file <<-END
-
-        class Reloader < Application
-        end
-
-        class Reloader2
-        end
-      END
-     
-    MockTimedExecutor.run_task
-    
-    defined?(Hello).should be_nil
-    defined?(Reloader).should_not be_nil
-    defined?(Reloader2).should_not be_nil
-  end
-
-  it "should remove classes for _abstract_subclasses" do
-    
-    update_file <<-END
-
-        class Reloader < Application
-        end
-
-        class Reloader2 < Application
-        end
-      END
-    
-    MockTimedExecutor.run_task
-
-    Merb::AbstractController._abstract_subclasses.should include("Reloader")
-    Merb::AbstractController._abstract_subclasses.should include("Reloader2")
-    defined?(Hello).should be_nil
-    defined?(Reloader).should_not be_nil
-    defined?(Reloader2).should_not be_nil
-  end
-
-  after :each do
-    update_file @text
-    MockTimedExecutor.run_task
-  end
-end

data/spec/public/request/multipart_spec.rb

@@ -1,41 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-require "mongrel"
-
-describe Merb::Request do
-  it "should handle file upload for multipart/form-data posts" do
-    file = Struct.new(:read, :filename, :path).
-      new("This is a text file with some small content in it.", "sample.txt", "sample.txt")
-    m = Merb::Test::MultipartRequestHelper::Post.new :file => file
-    body, head = m.to_multipart
-    request = fake_request({:request_method => "POST", :content_type => head, :content_length => body.length}, :req => body)
-    request.params[:file].should_not be_nil
-    request.params[:file][:tempfile].class.should == Tempfile
-    request.params[:file][:content_type].should == 'text/plain'
-  end
-  
-  it "should accept env['rack.input'] as IO object (instead of StringIO)" do
-    file = Struct.new(:read, :filename, :path).
-      new("This is a text file with some small content in it.", "sample.txt", "sample.txt")
-    m = Merb::Test::MultipartRequestHelper::Post.new :file => file
-    body, head = m.to_multipart
-    
-    t = Tempfile.new("io")
-    t.write(body)
-    t.close
-    
-    fd = IO.sysopen(t.path)
-    io = IO.for_fd(fd,"r")
-    request = Merb::Test::RequestHelper::FakeRequest.new({:request_method => "POST", :content_type => 'multipart/form-data, boundary=----------0xKhTmLbOuNdArY', :content_length => body.length},io)
-
-    running {request.params}.should_not raise_error        
-    request.params[:file].should_not be_nil
-    request.params[:file][:tempfile].class.should == Tempfile
-    request.params[:file][:content_type].should == 'text/plain'
-  end    
-    
-  it "should handle GET with a content_type but an empty body (happens in some browsers such as safari after redirect)" do
-      request = fake_request({:request_method => "GET", :content_type => 'multipart/form-data, boundary=----------0xKhTmLbOuNdArY', :content_length => 0}, :req => '')      
-      running {request.params}.should_not raise_error        
-  end
-  
-end

data/spec/public/request/request_spec.rb

@@ -1,250 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-require "mongrel"
-
-describe Merb::Request, "#method" do
-  
-  [:get, :head, :put, :delete].each do |method|
-    it "should use the HTTP if it was a #{method.to_s.upcase}" do
-      fake_request(:request_method => method.to_s).method.should == method
-    end
-
-    it "should use the _method body params for #{method.to_s.upcase} when it came in as a POST" do
-      request = fake_request({:request_method => "POST"}, :post_body => "_method=#{method}")
-      request.method.should == method
-    end
-    
-    it "should use the _method query params for #{method.to_s.upcase} when it came in as a POST" do
-      Merb::Request.parse_multipart_params = false
-      request = fake_request(:request_method => "POST", :query_string => "_method=#{method}")
-      request.method.should == method      
-    end
-    
-    [:get, :head, :put, :delete].each do |meth|
-      it "should return #{method == meth} when calling #{meth}? and the method is :#{method}" do
-        request = fake_request({:request_method => method.to_s})
-        request.send("#{meth}?").should == (method == meth)
-      end
-    end
-  end
-
-  it "should not try to parse the request body as JSON on GET" do
-    request = fake_request({:request_method => "GET", :content_type => "application/json"}, :req => "")
-    lambda { request.params }.should_not raise_error(JSON::ParserError)
-    request.params.should == {}
-  end
-  
-  it "should return an empty hash when XML is not parsable" do
-    request = fake_request({:content_type => "application/xml"}, :req => '')
-    lambda { request.params }.should_not raise_error
-    request.params.should == {}
-  end
-  
-  it "should default to POST if the _method is not defined" do
-    request = fake_request({:request_method => "POST"}, :post_body => "_method=zed")
-    request.method.should == :post
-  end
-  
-  it "should raise an error if an unknown method is used" do
-    request = fake_request({:request_method => "foo"})
-    running {request.method}.should raise_error
-  end
-    
-end
-
-describe Merb::Request, " query and body params" do
-  
-  before(:all) { Merb::BootLoader::Dependencies.enable_json_gem }
-  
-  TEST_PARAMS = {
-    "foo=bar&baz=bat"                       => {"foo" => "bar", "baz" => "bat"},
-    "foo=bar&foo=baz"                       => {"foo" => "baz"},
-    "foo[]=bar&foo[]=baz"                   => {"foo" => ["bar", "baz"]},
-    "foo[][bar]=1&foo[][bar]=2"             => {"foo" => [{"bar" => "1"},{"bar" => "2"}]},
-    "foo[bar][][baz]=1&foo[bar][][baz]=2"   => {"foo" => {"bar" => [{"baz" => "1"},{"baz" => "2"}]}},
-    "foo[1]=bar&foo[2]=baz"                 => {"foo" => {"1" => "bar", "2" => "baz"}},
-    
-    "foo[bar][baz]=1&foo[bar][zot]=2&foo[bar][zip]=3&foo[bar][buz]=4" => {"foo" => {"bar" => {"baz" => "1", "zot" => "2", "zip" => "3", "buz" => "4"}}},
-    "foo[bar][][baz]=1&foo[bar][][zot]=2&foo[bar][][zip]=3&foo[bar][][buz]=4" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2", "zip" => "3", "buz" => "4"}]}},
-    "foo[bar][][baz]=1&foo[bar][][zot]=2&foo[bar][][baz]=3&foo[bar][][zot]=4" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2"},{"baz" => "3", "zot" => "4"}]}},
-    "foo[bar][][baz]=1&foo[bar][][zot]=2&foo[bar][][fuz]=A&foo[bar][][baz]=3&foo[bar][][zot]=4&foo[bar][][fuz]=B" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2", "fuz" => "A"},{"baz" => "3", "zot" => "4", "fuz" => "B"}]}},
-    "foo[bar][][baz]=1&foo[bar][][zot]=2&foo[bar][][fuz]=A&foo[bar][][baz]=3&foo[bar][][zot]=4&foo[bar][][foz]=C" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2", "fuz" => "A"},{"baz" => "3", "zot" => "4", "foz" => "C"}]}},
-    "foo[bar][][baz]=1&foo[bar][][zot]=2&foo[bar][][fuz]=A&foo[bar][][baz]=3&foo[bar][][zot]=4" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2", "fuz" => "A"},{"baz" => "3", "zot" => "4"}]}},
-    "foo[bar][][baz]=1&foo[bar][][zot]=2&foo[bar][][fuz]=A&foo[bar][][baz]=3&foo[bar][][zot]=4&foo[bar][][fuz]=B&foo[bar][][foz]=C" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2", "fuz" => "A"},{"baz" => "3", "zot" => "4", "fuz" => "B", "foz" => "C"}]}},
-    "foo[][bar][][baz]=1&foo[][bar][][zot]=2&foo[][bar][][fuz]=A&foo[][bar][][baz]=3&foo[][bar][][zot]=4&foo[][bar][][fuz]=B&foo[][bar][][foz]=C" => {"foo" => {"bar" => [{"baz" => "1", "zot" => "2", "fuz" => "A"},{"baz" => "3", "zot" => "4", "fuz" => "B", "foz" => "C"}]}}
-  }
-  
-  TEST_PARAMS.each do |query, parse|
-
-     it "should convert #{query.inspect} to #{parse.inspect} in the query string" do
-       request = fake_request({:query_string => query})
-       request.params.should == parse
-     end
-
-     it "should convert #{query.inspect} to #{parse.inspect} in the post body" do
-       request = fake_request({}, :post_body => query)
-       request.params.should == parse
-     end
-   
-   end
-   
-  it "should support JSON params" do
-    request = fake_request({:content_type => "application/json"}, :req => %{{"foo": "bar"}})
-    request.params.should == {"foo" => "bar"}
-  end
-  
-  it "should populated the inflated_object parameter if JSON params do not inflate to a hash" do
-    request = fake_request({:content_type => "application/json"}, :req => %{["foo", "bar"]})
-    request.params.should have_key(:inflated_object)
-    request.params[:inflated_object].should eql(["foo", "bar"])
-  end
-  
-  it "should support XML params" do
-    request = fake_request({:content_type => "application/xml"}, :req => %{<foo bar="baz"><baz/></foo>})
-    request.params.should == {"foo" => {"baz" => nil, "bar" => "baz"}}
-  end  
-  
-end
-
-describe Merb::Request, "#remote_ip" do
-  it "should be able to get the remote IP of a request with X_FORWARDED_FOR" do
-    request = fake_request({:http_x_forwarded_for => "www.example.com"})
-    request.remote_ip.should == "www.example.com"
-  end
-  
-  it "should be able to get the remote IP when some of the X_FORWARDED_FOR are local" do
-    request = fake_request({:http_x_forwarded_for => "192.168.2.1,127.0.0.1,www.example.com"})
-    request.remote_ip.should == "www.example.com"
-  end
-  
-  it "should be able to get the remote IP when it's in REMOTE_ADDR" do
-    request = fake_request({:remote_addr => "www.example.com"})
-    request.remote_ip.should == "www.example.com"    
-  end
-end
-
-describe Merb::Request, "#cookies" do
-  
-  it "should take cookies in the HTTP_COOKIE environment variable" do
-    request = fake_request({:http_cookie => "merb=canhascookie; version=1"})
-    request.cookies.should == {"merb" => "canhascookie", "version" => "1"}
-  end
-  
-  it "should handle badly formatted cookies" do
-    request = fake_request({:http_cookie => "merb=; ; also=hats"})
-    request.cookies.should == {"merb" => "", "also" => "hats", "" => nil}
-  end
-  
-end
-
-describe Merb::Request, " misc" do
-  
-  it "should know if a request is an XHR" do
-    request = fake_request({:http_x_requested_with => "XMLHttpRequest"})
-    request.should be_xhr
-  end
-  
-  it "should know if the protocol is http or https (when HTTPS is on)" do
-    request = fake_request({:https => "on"})
-    request.protocol.should == "https://"
-    request.should be_ssl
-  end
-
-  it "should know if the protocol is http or https (when HTTP_X_FORWARDED_PROTO is https)" do
-    request = fake_request({:http_x_forwarded_proto => "https"})
-    request.protocol.should == "https://"
-    request.should be_ssl
-  end
-
-  it "should know if the protocol is http or https (when it's regular HTTP)" do
-    request = fake_request({})
-    request.protocol.should == "http://"
-  end
-  
-  it "should get the content-length" do
-    request = fake_request({:content_length => "300"})
-    request.content_length.should == 300
-  end
-  
-  it "should be able to get the path from the URI (stripping trailing /)" do
-    request = fake_request({:request_uri => "foo/bar/baz/?bat"})
-    request.path.should == "foo/bar/baz"
-  end
-  
-  it "should be able to get the path from the URI (joining multiple //)" do
-    request = fake_request({:request_uri => "foo/bar//baz/?bat"})
-    request.path.should == "foo/bar/baz"
-  end
-  
-  it "should get the remote port" do
-    request = fake_request({:server_port => "80"})
-    request.port.should == 80
-  end
-  
-  it "should get the parts of the remote subdomain" do
-    request = fake_request({:http_host => "zoo.boom.foo.com"})
-    request.subdomains.should == ["zoo", "boom"]
-  end
-  
-  it "should get the parts of the remote subdomain when there's an irregular TLD number" do
-    request = fake_request({:http_host => "foo.bar.co.uk"})
-    request.subdomains(2).should == ["foo"]
-  end
-  
-  it "should get the full domain (not including subdomains and not including the port)" do
-    request = fake_request({:http_host => "www.foo.com:80"})
-    request.domain.should == "foo.com"
-  end
-
-  it "should get the full domain from an irregular TLD" do
-    request = fake_request({:http_host => "www.foo.co.uk:80"})
-    request.domain(2).should == "foo.co.uk"
-  end
-
-  it "should get the host (with X_FORWARDED_HOST)" do
-    request = fake_request({:http_x_forwarded_host => "www.example.com"})
-    request.host.should == "www.example.com"
-  end
-
-  it "should get the host (without X_FORWARDED_HOST)" do
-    request = fake_request({:http_host => "www.example.com"})
-    request.host.should == "www.example.com"
-  end
-    
-  {:http_referer            => ["referer", "http://referer.com"],
-   :request_uri             => ["uri", "http://uri.com/uri"],
-   :http_user_agent         => ["user_agent", "mozilla"],
-   :server_name             => ["server_name", "apache"],
-   :http_accept_encoding    => ["accept_encoding", "application/json"],
-   :script_name             => ["script_name", "foo"],
-   :http_cache_control      => ["cache_control", "no-cache"],
-   :http_accept_language    => ["accept_language", "en"],
-   :server_software         => ["server_software", "apache"],
-   :http_keep_alive         => ["keep_alive", "300"],
-   :http_accept_charset     => ["accept_charset", "UTF-8"],
-   :http_version            => ["version", "1.1"],
-   :gateway_interface       => ["gateway", "CGI/1.2"],
-   :http_connection         => ["connection", "keep-alive"],
-   :path_info               => ["path_info", "foo/bar/baz"],
-  }.each do |env, vars|
-    
-    it "should be able to get the #{env.to_s.upcase}" do
-      request = fake_request({env => vars[1]})
-      request.send(vars[0]).should == vars[1]
-    end
-    
-  end
-  
-end
-
-describe Merb::Request, "#if_none_match" do
-  it 'returns value of If-None-Match request header' do
-    fake_request(Merb::Const::HTTP_IF_NONE_MATCH => "dc1562a133").if_none_match.should == "dc1562a133"
-  end
-end
-
-describe Merb::Request, "#if_modified_since" do
-  it 'returns value of If-Modified-Since request header' do
-    t = '05 Sep 2008 22:00:27 GMT'
-    fake_request(Merb::Const::HTTP_IF_MODIFIED_SINCE => t).if_modified_since.should == Time.rfc2822(t)
-  end
-end

data/spec/public/router/default_spec.rb

@@ -1,21 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe "The default routes" do
-  
-  before :each do
-    Merb::Router.prepare {|r| r.default_routes}
-  end
-    
-  it "should match /foo to the Foo controller and index action" do
-    route_to("/foo").should have_route(:controller => "foo", :action => "index", :id => nil)
-  end
-  
-  it "should match /foo/bar to the Foo controller and the bar action" do
-    route_to("/foo/bar").should have_route(:controller => "foo", :action => "bar", :id => nil)
-  end
-  
-  it "should match /foo/bar/12 to the Foo controller, the bar action, and id of 12" do
-    route_to("/foo/bar/12").should have_route(:controller => "foo", :action => "bar", :id => "12")
-  end
-  
-end

data/spec/public/router/deferred_spec.rb

@@ -1,22 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe "Deferred routes" do
-
-  before :each do
-    Merb::Router.prepare do |r|      
-      r.match("/deferred/:zoo").defer_to do |request, params|
-        params.merge(:controller => "w00t") if params[:zoo]
-      end
-      r.default_routes
-    end    
-  end
-  
-  it "should match routes based on the incoming params" do
-    route_to("/deferred/baz", :boo => "12").should have_route(:controller => "w00t", :zoo => "baz")
-  end
-
-  it "should fall back to the default route if the deferred condition is not met" do
-    route_to("/deferred").should have_route(:controller => "deferred", :action => "index")    
-  end
-  
-end

data/spec/public/router/fixation_spec.rb

@@ -1,49 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-module Merb::Test::Fixtures
-  module Controllers
-    class FixatableRoutes < Merb::Controller
-      
-      def fixoid
-      end
-      
-    end
-  end
-end
-
-describe "A route marked as fixatable" do
-  predicate_matchers[:allow_fixation] = :allow_fixation?
-
-  before do
-    Merb::Router.prepare do |r|
-      r.match("/hello/:action/:id").to(
-        :controller => "merb/test/fixtures/controllers/fixatable_routes", 
-        :action => "fixoid").fixatable
-    end
-  end
-
-  it "allows fixation" do
-    matched_route_for("/hello/goodbye/tagging").should allow_fixation
-  end
-  
-  it "should store a cookie with the session_id" do
-    session_id = Merb::SessionMixin.rand_uuid
-    request = fake_request(:request_uri => "/hello/goodbye/tagging", 
-      :query_string => "_session_id=#{session_id}")
-    controller = ::Merb::Dispatcher.handle(request)
-    controller.params["_session_id"].should == session_id
-    controller.request.session_cookie_value.should == session_id
-  end
-end
-
-describe "A route NOT marked as fixatable" do
-  predicate_matchers[:allow_fixation] = :allow_fixation?
-
-  it "DOES NOT allow fixation" do
-    Merb::Router.prepare do |r|
-      r.match("/hello/:action/:id").to(:controller => "foo", :action => "fixoid")
-    end
-
-    matched_route_for("/hello/goodbye/tagging").should_not allow_fixation
-  end
-end