merb-core 1.0.15 → 1.1.0.pre

data/spec10/public/router/router_spec.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Merb::Router do
+  
+  describe "#prepare" do
+    
+    it "should be able to compile an empty route table" do
+      lambda do
+        Merb::Router.prepare { }
+      end.should_not raise_error(SyntaxError)
+    end
+    
+    it "should evaluate the prepare block in context an object that provides builder methods" do
+      Merb::Router.prepare do
+        %w(
+          match to defaults options fixatable
+          name full_name defer_to default_routes
+          namespace redirect resources resource
+        ).each do |method|
+          respond_to?(method).should == true
+        end
+      end
+    end
+    
+    it "should use the default root_behavior if none is specified" do
+      Merb::Router.prepare do
+        match("/hello").to(:controller => "hello")
+      end
+      
+      route_for("/hello").should have_route(:controller => "hello", :action => "index")
+    end
+    
+    it "should use the root_behavior specified externally" do
+      Merb::Router.root_behavior = Merb::Router.root_behavior.defaults(:controller => "default")
+      Merb::Router.prepare do
+        match("/hello").register
+      end
+      
+      route_for("/hello").should have_route(:controller => "default", :action => "index")
+    end
+    
+    it "should be able to chain root_behaviors" do
+      Merb::Router.root_behavior = Merb::Router.root_behavior.defaults(:controller => "default")
+      Merb::Router.root_behavior = Merb::Router.root_behavior.defaults(:action     => "default")
+      Merb::Router.prepare do
+        match("/hello").register
+      end
+      
+      route_for("/hello").should have_route(:controller => "default", :action => "default")
+    end
+    
+    it "should raise a friendly error when there is some :controller mismatching going on" do
+      lambda {
+        Merb::Router.prepare do
+          match("/").to(:controller => "hello/:controller")
+        end
+      }.should raise_error(Merb::Router::GenerationError)
+    end
+    
+    it "should empty previously set #routes, #resource_routes, and #named_routes" do
+      Merb::Router.prepare do
+        resources :users
+      end
+      Merb::Router.prepare { }
+      
+      Merb::Router.routes.should be_empty
+      Merb::Router.named_routes.should be_empty
+      Merb::Router.resource_routes.should be_empty
+    end
+    
+    it "should not be able to match routes anymore" do
+      lambda { route_for("/users") }.should raise_error(Merb::Router::NotCompiledError)
+    end
+    
+    it "should log at the debug level when it cannot find a resource model" do
+      with_level(:info) do
+        Merb::Router.prepare { resources :zomghi2u }
+      end.should_not include_log("Could not find resource model Zonghi2u")
+      
+      with_level(:debug) do
+        Merb::Router.prepare { resources :zomghi2u }
+      end.should include_log("Could not find resource model Zomghi2u")
+    end
+  end
+
+  describe "#match" do
+    
+    it "should raise an error if the routes were not compiled yet" do
+      lambda { Merb::Router.match(simple_request) }.should raise_error(Merb::Router::NotCompiledError)
+    end
+
+  end
+  
+  describe "#extensions" do
+    it "should be able to extend the router" do
+      Merb::Router.extensions do
+        def hello_world
+          match("/hello").to(:controller => "world")
+        end
+      end
+      
+      Merb::Router.prepare do
+        hello_world
+      end
+      
+      route_for("/hello").should have_route(:controller => "world")
+    end
+  end
+  
+  describe "#around_match" do
+    
+    it "should set a class method of Router to be called around request matching" do
+      class Merb::Router
+        def self.my_awesome_thang(request)
+          before!
+          retval = yield
+          after!
+          retval
+        end
+      end
+      
+      Merb::Router.around_match = :my_awesome_thang
+      Merb::Router.prepare do
+        match("/").to(:controller => "home")
+      end
+      
+      Merb::Router.should_receive(:before!)
+      Merb::Router.should_receive(:after!)
+      route_for("/").should have_route(:controller => "home")
+    end
+    
+  end
+
+end

data/spec10/public/router/spec_helper.rb

@@ -0,0 +1,287 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+require 'ostruct'
+require 'rubygems'
+gem "rspec"
+require "spec"
+
+module Spec
+  module Matchers
+    class HaveRoute
+      def initialize(expected, exact = false)
+        @expected = expected
+        @exact = exact
+      end
+
+      def matches?(target)
+        @target = target[1]
+        @errors = []
+        @expected.all? { |param, value| @target[param] == value } && (!@exact || @expected.length == @target.length)
+      end
+
+      def failure_message
+        @target.each do |param, value|
+          @errors << "Expected :#{param} to be #{@expected[param].inspect}, but was #{value.inspect}" unless
+            @expected[param] == value
+        end
+        @errors << "Got #{@target.inspect}"
+        @errors.join("\n")
+      end
+
+      def negative_failure_message
+        "Expected #{@expected.inspect} not to be #{@target.inspect}, but it was."
+      end
+
+      def description() "have_route #{@target.inspect}" end
+    end
+
+    def have_route(expected)
+      HaveRoute.new(expected)
+    end
+    
+    def have_exact_route(expected)
+      HaveRoute.new(expected, true)
+    end
+    
+    class HaveRack
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(rack)
+        return false unless rack.last.is_a?(Array)
+        @actual = Struct.new(:status, :headers, :body).new(rack.last[0], rack.last[1], rack.last[2])
+        @expected.all? { |k, v| @actual[k] == v }
+      end
+
+      def failure_message
+        "#{@actual.inspect} does not match #{@expected.inspect}"
+      end
+
+      def negative_failure_message
+        "#{@actual.inspect} does match #{@expected.inspect}"
+      end
+
+      def description() "have_rack #{@actual.inspect}" end
+    end
+    
+    def have_rack(expected)
+      HaveRack.new(expected)
+    end
+    
+    # class HaveNilRoute
+    # 
+    #   def matches?(target)
+    #     @target = target
+    #     target.last.empty?
+    #   end
+    # 
+    #   def failure_message
+    #     "Expected a nil route. Got #{@target.inspect}."
+    #   end
+    # 
+    #   def negative_failure_message
+    #     "Expected not to get a nil route."
+    #   end
+    # end
+    # 
+    def raise_not_found
+      raise_error(Merb::ControllerExceptions::NotFound)
+    end
+  end
+  
+  module Helpers
+    #
+    # Creates a single route with the passed conditions and parameters without
+    # registering it with Router
+    # def route(conditions, params = {})
+    #   conditions = {:path => conditions} unless Hash === conditions
+    #   Merb::Router::Route.new(conditions, params)
+    # end
+    # 
+    # #
+    # # A shortcut for creating a single route and registering it with Router
+    # def prepare_named_route(name, from, conditions = {}, to = nil)
+    #   to, conditions = conditions, {} unless to
+    #   Merb::Router.prepare {|r| r.match(from, conditions).to(to).name(name) }
+    # end
+    # 
+    # def prepare_conditional_route(name, from, conditions, to = {})
+    #   Merb::Router.prepare {|r| r.match(from, conditions).to(to).name(name) }
+    # end
+    # 
+    def prepare_route(from = {}, to = {})
+      name = :default
+      Merb::Router.prepare {|r| r.match(from).to(to).name(name) }
+    end
+    
+    def env_for(path, orig_env = {})
+      env = orig_env.dup
+      env["REQUEST_METHOD"]  = env.delete(:method).to_s if env[:method]
+      env["HTTP_USER_AGENT"] = env.delete(:user_agent)  if env[:user_agent]
+      env["HTTPS"]           = "on"                     if env.delete(:protocol) =~ /https/i
+      env["REQUEST_PATH"]    = path
+      
+      if env[:host]
+        env["HTTP_HOST"] = env.delete(:host)
+      elsif env[:domain]
+        env["HTTP_HOST"] = env.delete(:domain)
+      end
+      
+      env
+    end
+    
+    def simple_request(env = {})
+      env_for("/", env)
+    end
+
+    #
+    # Returns the dispatch parameters for a request by passing the request
+    # through Router#match.
+    def route_for(path, env = {}, &block)
+      request = fake_request(env_for(path, env))
+      yield request if block_given?
+      Merb::Router.route_for(request)
+    end
+    
+    def request_for(path, env = {}, &block)
+      request = fake_request(env_for(path, env))
+      yield request if block_given?
+      Merb::Router.route_for(request)
+      request
+    end
+    
+    def matched_route_for(*args)
+      route_for(*args).first
+    end
+
+  end
+end
+
+def it_should_be_a_resource_collection_route(name, *args)
+  params = extract_options_from_args!(args) || {}
+  prefix = args.first.is_a?(String) ? args.shift : ""
+  opts   = args.first.is_a?(Hash)   ? args.shift : {}
+  
+  id = opts[:id] || "45"
+  
+  it "should provide #{name} with an 'index' route" do
+    route_for("#{prefix}/#{name}").should          have_route({:action => "index", :controller => "#{name}",  :id => nil, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/index").should    have_route({:action => "index", :controller => "#{name}",  :id => nil, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}.js").should       have_route({:action => "index", :controller => "#{name}",  :id => nil, :format => "js"}.merge(params))
+    route_for("#{prefix}/#{name}/index.js").should have_route({:action => "index", :controller => "#{name}",  :id => nil, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'new' route" do
+    route_for("#{prefix}/#{name}/new").should    have_route({:action => "new", :controller => "#{name}", :id => nil, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/new.js").should have_route({:action => "new", :controller => "#{name}", :id => nil, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'create' route" do
+    route_for("#{prefix}/#{name}",    :method => :post).should have_route({:action => "create", :controller => "#{name}", :id => nil, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}.js", :method => :post).should have_route({:action => "create", :controller => "#{name}", :id => nil, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'show' route" do
+    route_for("#{prefix}/#{name}/#{id}").should    have_route({:action => "show", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/#{id}.js").should have_route({:action => "show", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with an 'edit' route" do
+    route_for("#{prefix}/#{name}/#{id}/edit").should    have_route({:action => "edit", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/#{id}/edit.js").should have_route({:action => "edit", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with an 'update' route" do
+    route_for("#{prefix}/#{name}/#{id}",    :method => :put).should have_route({:action => "update", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/#{id}.js", :method => :put).should have_route({:action => "update", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'delete' route" do
+    route_for("#{prefix}/#{name}/#{id}/delete").should    have_route({:action => "delete", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/#{id}/delete.js").should have_route({:action => "delete", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'destroy' route" do
+    route_for("#{prefix}/#{name}/#{id}",    :method => :delete).should have_route({:action => "destroy", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/#{id}.js", :method => :delete).should have_route({:action => "destroy", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+  end
+
+  # --- I decided that all the routes here will have the following ---
+  
+  if !opts.has_key?(:extra) || opts[:extra]
+    
+    it "should provide #{name} with a 'one' collection route" do
+      route_for("#{prefix}/#{name}/one").should    have_route({:action => "one", :controller => "#{name}", :format => nil }.merge(params))
+      route_for("#{prefix}/#{name}/one.js").should have_route({:action => "one", :controller => "#{name}", :format => "js"}.merge(params))
+    end
+
+    it "should provide #{name} with a 'two' member route" do
+      route_for("#{prefix}/#{name}/#{id}/two").should    have_route({:action => "two", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+      route_for("#{prefix}/#{name}/#{id}/two.js").should have_route({:action => "two", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+    end
+
+    it "should provide #{name} with a 'three' collection route that maps the 'awesome' method" do
+      route_for("#{prefix}/#{name}/three").should    have_route({:action => "awesome", :controller => "#{name}", :format => nil }.merge(params))
+      route_for("#{prefix}/#{name}/three.js").should have_route({:action => "awesome", :controller => "#{name}", :format => "js"}.merge(params))
+    end
+
+    it "should provide #{name} with a 'four' member route that maps to the 'awesome' method" do
+      route_for("#{prefix}/#{name}/#{id}/four").should    have_route({:action => "awesome", :controller => "#{name}", :id => id, :format => nil }.merge(params))
+      route_for("#{prefix}/#{name}/#{id}/four.js").should have_route({:action => "awesome", :controller => "#{name}", :id => id, :format => "js"}.merge(params))
+    end
+  end
+end
+
+def it_should_be_a_resource_object_route(name, *args)
+  controller = "#{name}s"
+  params     = extract_options_from_args!(args) || {}
+  prefix     = args.first.is_a?(String) ? args.shift : ""
+  opts       = args.first.is_a?(Hash)   ? args.shift : {}
+
+  it "should provide #{name} with a 'show' route" do
+    route_for("#{prefix}/#{name}").should    have_route({:action => "show", :controller => controller, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}.js").should have_route({:action => "show", :controller => controller, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with an 'edit' route" do
+    route_for("#{prefix}/#{name}/edit").should    have_route({:action => "edit", :controller => controller, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/edit.js").should have_route({:action => "edit", :controller => controller, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with an 'update' route" do
+    route_for("#{prefix}/#{name}",    :method => :put).should have_route({:action => "update", :controller => controller, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}.js", :method => :put).should have_route({:action => "update", :controller => controller, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'delete' route" do
+    route_for("#{prefix}/#{name}/delete").should    have_route({:action => "delete", :controller => controller, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/delete.js").should have_route({:action => "delete", :controller => controller, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'destroy' route" do
+    route_for("#{prefix}/#{name}",    :method => :delete).should have_route({:action => "destroy", :controller => controller, :format => nil}.merge(params))
+    route_for("#{prefix}/#{name}.js", :method => :delete).should have_route({:action => "destroy", :controller => controller, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'one' member route" do
+    route_for("#{prefix}/#{name}/one").should    have_route({:action => "one", :controller => controller, :format => nil}.merge(params))
+    route_for("#{prefix}/#{name}/one.js").should have_route({:action => "one", :controller => controller, :format => "js"}.merge(params))
+  end
+
+  it "should provide #{name} with a 'two' member route that maps to the 'awesome' method" do
+    route_for("#{prefix}/#{name}/two").should    have_route({:action => "awesome", :controller => controller, :format => nil }.merge(params))
+    route_for("#{prefix}/#{name}/two.js").should have_route({:action => "awesome", :controller => controller, :format => "js"}.merge(params))
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(Spec::Helpers)
+  config.include(Spec::Matchers)
+  config.before(:each) do
+    @_root_behavior = Merb::Router.root_behavior
+  end
+  config.after(:each) do
+    Merb::Router.root_behavior = @_root_behavior
+    Merb::Router.reset!
+  end
+end

data/spec10/public/router/spec_helper_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "env_for" do
+  describe "with :method" do
+    before(:each) do
+      @orig_env = { :method => "POST" }
+    end
+  
+    it "should preserve the passed environment" do
+      env_for("/", @orig_env)
+      @orig_env.should == { :method => "POST" }
+    end
+
+    it "should return REQUEST_PATH and REQUEST_METHOD" do
+      env_for("/", @orig_env).should == { "REQUEST_PATH" => "/", "REQUEST_METHOD" => "POST" }
+    end
+  end
+
+  describe "with :user_agent" do
+    before(:each) do
+      @orig_env = { :user_agent => "Safari" }
+    end
+  
+    it "should preserve the passed environment" do
+      env_for("/", @orig_env)
+      @orig_env.should == { :user_agent => "Safari" }
+    end
+
+    it "should return REQUEST_PATH and HTTP_USER_AGENT" do
+      env_for("/", @orig_env).should == { "REQUEST_PATH" => "/", "HTTP_USER_AGENT" => "Safari" }
+    end
+  end
+end

data/spec10/public/session/controllers/sessions.rb

@@ -0,0 +1,61 @@
+module Merb
+  
+  module Test
+    module Fixtures
+  
+      module Controllers
+
+        class Testing < Merb::Controller
+          self._template_root = File.dirname(__FILE__) / "views"
+        end
+
+        class SessionsController < Testing
+    
+          def index
+            request.session[:foo] = params[:foo]
+            Merb::Config[:session_store]
+          end
+      
+          def regenerate
+            request.session.regenerate
+          end
+      
+          def retrieve
+          end
+      
+          def destroy
+            request.session.clear!
+          end
+    
+        end
+    
+        class MultipleSessionsController < Testing
+    
+          def store_in_cookie
+            request.session(:cookie)[:foo] = 'cookie-bar'
+          end
+      
+          def store_in_memory
+            request.session(:memory)[:foo] = 'memory-bar'
+          end
+      
+          def store_in_memcache
+            request.session(:memcache)[:foo] = 'memcache-bar'
+          end
+      
+          def store_in_multiple
+            request.session(:memcache)[:foo] = 'memcache-baz'
+            request.session(:memory)[:foo] = 'memory-baz'
+            request.session(:cookie)[:foo] = 'cookie-baz'
+          end
+      
+          def retrieve
+          end
+      
+        end
+  
+      end
+
+    end
+  end
+end

data/spec10/public/session/cookie_session_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+startup_merb(:session_store => "cookie", :session_secret_key => "session-secret-key-here")
+require File.join(File.dirname(__FILE__), "controllers", "sessions")
+
+describe Merb::CookieSession do
+  
+  before do 
+    @session_class = Merb::CookieSession
+    @session = @session_class.generate
+  end
+  
+  it_should_behave_like "All session-store backends"
+  
+  it "should have a session_store_type class attribute" do
+    @session.class.session_store_type.should == :cookie
+  end
+  
+end
+
+describe Merb::CookieSession, "mixed into Merb::Controller" do
+  
+  before(:all) { @controller_klass = Merb::Test::Fixtures::Controllers::SessionsController }
+  
+  it "should represent the controller session" do
+    controller = dispatch_to(@controller_klass, :index)
+    controller.body.should == "cookie"
+    controller.request.session.should be_kind_of(Merb::CookieSession)
+  end
+  
+  it "should store and retrieve session data" do
+    with_cookies(@controller_klass) do
+      controller = dispatch_to(@controller_klass, :index, :foo => "cookie")
+      controller.request.session[:foo].should == "cookie"
+    
+      controller = dispatch_to(@controller_klass, :retrieve)
+      controller.request.session[:foo].should == "cookie"
+    end
+  end
+  
+  it "should allow regeneration of the session" do
+    with_cookies(@controller_klass) do
+      controller = dispatch_to(@controller_klass, :index, :foo => "cookie")
+      controller = dispatch_to(@controller_klass, :regenerate)
+      controller = dispatch_to(@controller_klass, :retrieve)
+      controller.request.session[:foo].should == "cookie"
+    end    
+  end
+    
+  it "shouldn't allow tampering with cookie data" do
+    with_cookies(@controller_klass) do |cookie_jar|
+      controller = dispatch_to(@controller_klass, :index, :foo => "cookie")
+      cookie_data, cookie_checksum = controller.cookies[Merb::Request._session_id_key].split('--')
+      cookie_data = 'tampered-with-data'
+      cookie_jar[Merb::Request._session_id_key] = "#{cookie_data}--#{cookie_checksum}"
+      controller = dispatch_to(@controller_klass, :retrieve)
+      lambda { controller.request.session }.should raise_error(Merb::CookieSession::TamperedWithCookie)
+    end
+  end
+    
+  it "shouldn't allow tampering with cookie fingerprints" do
+    with_cookies(@controller_klass) do |cookie_jar|
+      controller = dispatch_to(@controller_klass, :index, :foo => "cookie")
+      cookie_data, cookie_checksum = controller.cookies[Merb::Request._session_id_key].split('--')
+      cookie_checksum = 'tampered-with-checksum'
+      cookie_jar[Merb::Request._session_id_key] = "#{cookie_data}--#{cookie_checksum}"
+      controller = dispatch_to(@controller_klass, :retrieve)
+      lambda { controller.request.session }.should raise_error(Merb::CookieSession::TamperedWithCookie)
+    end
+  end
+  
+end

data/spec10/public/session/memcached_session_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+startup_merb(:session_store => "memcache")
+
+require File.join(File.dirname(__FILE__), "controllers", "sessions")
+
+require 'memcache'
+Merb::MemcacheSession.store = MemCache.new('127.0.0.1:11211', { :namespace => 'my_app' })
+
+begin
+  Merb::MemcacheSession.store.stats  
+rescue MemCache::MemCacheError
+  puts "\nWarning: no connection to MemCache server at 127.0.0.1:11211 - some specs will fail!\n\n"
+end
+
+describe Merb::MemcacheSession do
+  
+  before do 
+    @session_class = Merb::MemcacheSession
+    @session = @session_class.generate
+  end
+  
+  it_should_behave_like "All session-store backends"
+  
+  it "should have a session_store_type class attribute" do
+    @session.class.session_store_type.should == :memcache
+  end
+  
+end
+
+describe Merb::MemcacheSession, "mixed into Merb::Controller" do
+  
+  before(:all) { @session_class = Merb::MemcacheSession }
+  
+  it_should_behave_like "All session-stores mixed into Merb::Controller"
+  
+end

data/spec10/public/session/memory_session_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+startup_merb(:session_store => "memory")
+require File.join(File.dirname(__FILE__), "controllers", "sessions")
+
+describe Merb::MemorySession do
+  
+  before do 
+    @session_class = Merb::MemorySession
+    @session = @session_class.generate
+  end
+  
+  it_should_behave_like "All session-store backends"
+  
+  it "should have a session_store_type class attribute" do
+    @session.class.session_store_type.should == :memory
+  end
+  
+end
+
+describe Merb::MemorySession, "mixed into Merb::Controller" do
+
+  before(:all) { @session_class = Merb::MemorySession }
+  
+  it_should_behave_like "All session-stores mixed into Merb::Controller"
+
+end