merb 0.4.0 → 0.4.1

data/spec/merb/controller_filters_spec.rb

@@ -0,0 +1,188 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class TestFiltersController < Merb::Controller
+  
+  before :filter1
+  before :will_halt, :only => :four
+  before Proc.new {|c| c.one }, :exclude => [:one, :three, :uses_params]
+  after  Proc.new {|c| c.five }, :exclude => [:one, :three, :uses_params]  
+  after  :filter2
+  before :modifies_param, :only => :uses_params
+  after :restores_param, :only => :uses_params
+  
+  
+  def will_halt
+    throw :halt
+  end
+  
+  def filters_halted
+    "Filters Halted"
+  end
+  
+  def modifies_param 
+    params[:the_param] ||= ''
+    params[:the_param_original] = params[:the_param]
+    params[:the_param] += ' is modified'
+  end
+  
+  def restores_param
+    params[:the_param] = params[:the_param_original] + ' is restored'
+    @used_params = params[:the_param]
+  end
+  
+  def filter1
+    @filter1='called'
+  end
+  
+  def filter2
+    @filter2='called'
+  end
+    
+  def one
+    session.data.should == {}
+    @one = 'one'
+  end
+  
+  def two
+    @two = 'two'
+  end
+  
+  def three
+    @three = 'three'
+  end
+  
+  def four
+    @four = 'four'
+  end
+  
+  def five
+    @five = 'five'
+  end
+  
+  def uses_params
+    @uses_params = params[:the_param]
+  end
+  
+end
+
+class TestDefaultFiltersHalted < Merb::Controller
+  before :will_halt
+  
+  def will_halt
+    throw :halt
+  end
+  
+  def one
+  end
+  
+end
+
+class TestPrivateActions < Merb::Controller
+  
+  protected
+  def notcallable1
+    "notcallable"
+  end
+  
+  private
+  def notcallable2
+    "notcallable"
+  end
+  
+end  
+describe "Dispatch and before/after filters" do
+  
+  def call_filter_action(action, extra_params = {})
+    @c = new_controller( action, TestFiltersController, extra_params )
+    @c.dispatch(action)
+  end
+
+  before :each do
+    request = Merb::Test::FakeRequest.new
+    @status, @response, @headers = 200, request.body, {'Content-Type' =>'text/html'}
+    @request, @cookies = request, {}
+  end
+  
+  it "should not allow calling protected actions" do
+    c = new_controller( 'notcallable1', TestPrivateActions )
+    lambda {c.dispatch(:notcallable1)}.should raise_error( Merb::ControllerExceptions::ActionNotFound)
+  end  
+  
+  it "should not allow calling private actions" do
+    c = new_controller( 'notcallable2', TestPrivateActions )
+    lambda {c.dispatch(:notcallable2)}.should raise_error( Merb::ControllerExceptions::ActionNotFound)
+  end
+
+  it "should call a :symbol before and after filter" do
+    c = new_controller( 'one', TestFiltersController )
+    c.dispatch(:one)
+    c.body.should == 'one'
+    c.instance_variable_get('@one').should == 'one' 
+    c.instance_variable_get('@two').should == nil
+    c.instance_variable_get('@three').should == nil 
+    c.instance_variable_get('@filter1').should == 'called'         
+  end
+  
+  it "should be able to see instance variables" do
+    call_filter_action "one"
+    @c.cookies.should be_is_a(Hash) 
+    @c.session.data.should == {}
+    @c.response.read.should == ""
+    @c.instance_variable_get("@filter1").should eql( 'called')
+    @c.instance_variable_get("@one").should eql( 'one')
+  end
+  
+  it "should ignore actions specified by :exclude" do
+    call_filter_action "three"
+    @c.instance_variable_get("@one").should be_nil
+    @c.instance_variable_get("@five").should be_nil    
+  end
+  
+  it "should be able to see params in the before filter" do
+    call_filter_action "uses_params", :the_param => 'the param'
+    @c.instance_variable_get("@uses_params").should eql( 'the param is modified')
+  end
+
+  it "should be able to see params in the after filter" do
+    call_filter_action "uses_params", :the_param => 'the param'
+    @c.instance_variable_get("@used_params").should eql( 'the param is restored')
+  end
+  
+  it "should call a Proc before and after filter" do
+    c = new_controller( 'two', TestFiltersController )
+    c.dispatch(:two)
+    c.body.should == 'two'
+    c.instance_variable_get('@one').should == 'one'
+    c.instance_variable_get('@two').should == 'two'
+    c.instance_variable_get('@three').should == nil 
+    c.instance_variable_get('@five').should == 'five'
+  end
+  
+  it "should call filters_halted when throw :halt" do
+    c = new_controller( 'four', TestFiltersController )
+    c.dispatch(:four)
+    c.body.should == "Filters Halted"
+    c.instance_variable_get('@one').should == nil
+    c.instance_variable_get('@two').should == nil
+    c.instance_variable_get('@three').should == nil 
+    c.instance_variable_get('@filter1').should == 'called' 
+  end
+  
+  it "should have a default filter halted page" do
+    c = new_controller( 'one', TestFiltersController )
+    c.dispatch(:one)
+  end
+  
+  it "should not allow both :only and :exclude" do
+    ["before", "after"].each do |filter_type|
+      lambda { TestFiltersController.send(filter_type, :x, :only => :foo, :exclude => :bar) }.should raise_error(ArgumentError)
+    end
+  end
+  
+  it "should not allow a filter that is not a symbol, string, or proc" do
+    ["before", "after"].each do |filter_type|    
+      lambda { TestFiltersController.send(filter_type, []) }.should raise_error(ArgumentError)
+    end
+  end
+
+end

data/spec/merb/controller_spec.rb

@@ -0,0 +1,144 @@
+require 'ostruct'
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Merb::Controller" do
+  
+  # not sure what this tests
+  # it "should instantiate" do
+  #   c = new_controller
+  #   @request.env.should == c.request.env
+  # end
+  
+  it "should have a default layout of application.rhtml" do
+    c = new_controller
+    c._layout.should == :application
+  end
+end
+
+describe Merb::Controller, "url generator tests" do
+  def new_url_controller(route, params = {:action => 'show', :controller => 'Test'})
+    request = OpenStruct.new
+    request.route = route
+    request.params = params
+    response = OpenStruct.new
+    response.read = ""
+    
+    Merb::Controller.build(request, response)
+  end
+  
+  before(:all) do
+    Merb::Router.prepare do |r|
+      @resource_routes = r.resources(:blogs)
+      r.resources(:gardens) do |gardens|
+        @nested_resource = gardens.resources :flowers
+      end
+      @test_route = r.match("/the/:place/:goes/here").to(:controller => "Test", :action => "show").name(:test)
+      @default_route = r.default_routes
+    end
+  end
+  
+  it "should generate a url from a route using a hash" do
+    c = new_url_controller(@test_route, :place => "1")
+    c.url_from_route(@test_route, :goes => "g").should == "/the/1/g/here"
+  end
+
+  it "should generate a url from a route using an object" do
+    c = new_url_controller(@test_route, :place => "2")
+    obj = OpenStruct.new(:goes => "elsewhere")
+    c.url_from_route(@test_route, obj).should == "/the/2/elsewhere/here"
+  end
+
+  it "should generate a url and tack extra params on as a query string" do
+    c = new_url_controller(@test_route, :place => "1")
+    c.url_from_route(@test_route, :goes => "g", :page => 2).should == "/the/1/g/here?page=2"
+  end
+  
+  it "should generate a url directly from a hash using the current route as a default" do
+    c = new_url_controller(@test_route, :goes => "swimmingly")
+    c.url(:place => "provo").should == "/the/provo/swimmingly/here"
+  end
+  
+  it "should generate a default route url with just :controller" do
+    c = new_url_controller(@default_route)
+    c.url(:controller => "welcome").should == "/welcome"
+  end
+
+  it "should generate a default route url with just :action" do
+    c = new_url_controller(@default_route, :controller => "foo")
+    c.url(:action => "baz").should == "/foo/baz"
+  end
+  
+  it "should generate a default route url with just :id" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    c.url(:id => "23").should == "/foo/bar/23"
+  end
+
+  it 'should generate urls from nested resources' do
+    c = new_url_controller(@nested_resource, :garden => 5)
+    c.url(:flower, :garden_id => 1, :id => 3).should == "/gardens/1/flowers/3"
+  end
+
+  it "should generate a default route url with an extra param" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    c.url(:controller => :current, :monkey => "quux").should == "/foo/bar?monkey=quux"
+  end
+
+  it "should generate a default route url with extra params" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    url = c.url(:controller => :current, :monkey => "quux", :cow => "moo")
+    url.should match(%r{/foo/bar?.*monkey=quux})
+    url.should match(%r{/foo/bar?.*cow=moo})
+  end
+
+  it "should generate a default route url with extra params and an array" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    c.url(:controller => :current, :monkey => [1,2]).should == "/foo/bar?monkey[]=1&monkey[]=2"
+  end
+  
+  it "should generate a default route url with extra params and a hash" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    c.url(:controller => :current, :animals => {:cow => "moo"}).should == "/foo/bar?animals[cow]=moo"
+  end
+
+  it "should generate a default route url with :action and :format" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    c.url(:action => :recent, :format => :txt).should == "/foo/recent.txt"
+  end  
+  
+  it "should generate a default route url with all options" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    c.url(:controller => "foo", :action => "bar", :id => "baz", :format => :js, :monkey => "quux").should == "/foo/bar/baz.js?monkey=quux"
+  end
+  
+  it "should handle nested nested and more nested hashes and arrays" do
+    c = new_url_controller(@default_route, :controller => "foo", :action => "bar")
+    url = c.url(:controller => :current, :user => {:filter => {:name => "quux*"}, :order => ["name"]})
+    url.should match(%r{/foo/bar?.*user\[filter\]\[name\]=quux%2A})
+    url.should match(%r{/foo/bar?.*user\[order\]\[\]=name})
+  end
+  
+  it "should handle an object as the second arg" do
+    c = new_url_controller(@resource_routes, :controller => "blogs", :action => "show")
+    blog = mock("blog")
+    blog.should_receive(:id).once.and_return(7)
+    url = c.url(:blog, blog)
+    url.should == "/blogs/7"
+  end
+
+  it "should point to /blogs/:blog_id if @blog is not new_record" do
+    c = new_url_controller(@resource_routes, :controller => "blogs", :action => "index")
+    blog = mock("blog")
+    blog.should_receive(:id).once.and_return(7)
+    blog.should_receive(:new_record?).once.and_return(false)
+    url = c.url(:blog, blog)
+    url.should == "/blogs/7"
+  end
+
+  it "should point to /blogs/ if @blog is new_record" do
+    c = new_url_controller(@resource_routes, :controller => "blogs", :action => "index")
+    blog = mock("blog")
+    blog.should_receive(:new_record?).once.and_return(true)
+    url = c.url(:blog, blog)
+    url.should == "/blogs/"
+  end
+end

data/spec/merb/cookie_store_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require "merb/session/cookie_store"
+
+class Merb::Controller
+  include ::Merb::SessionMixin
+end
+
+class TestCookieSessionController < Merb::Controller
+  
+  def change
+    session[:hello] = 'world'
+  end
+  
+  def no_change
+    "test"
+  end
+  
+end
+
+Merb::Server.config[:session_secret_key] = 'Secret!'
+
+describe Merb::SessionMixin do
+  it "should set the cookie if the cookie is changed" do
+    c = new_controller( 'change', TestCookieSessionController)
+    c.dispatch(:change)
+    c.headers['Set-Cookie'].should =~ %r{_session_id=} # this could be better
+  end
+end
+
+describe Merb::CookieStore do
+  
+  def cookies(*which)
+    @cookies.values_at(*which)
+  end
+  
+  def cookie_value(which)
+    @cookies[which].first
+  end
+  
+  before(:each) do
+    @secret = 'Keep it secret; keep it safe.'
+    @cookies = { 
+      :empty => ['BAgw--0686dcaccc01040f4bd4f35fe160afe9bc04c330', {}],
+      :a_one => ['BAh7BiIGYWkG--5689059497d7f122a7119f171aef81dcfd807fec', { 'a' => 1 }],
+      :typical => ['BAh7ByIMdXNlcl9pZGkBeyIKZmxhc2h7BiILbm90aWNlIgxIZXkgbm93--9d20154623b9eeea05c62ab819be0e2483238759', { 'user_id' => 123, 'flash' => { 'notice' => 'Hey now' }}],
+      :flashed => ['BAh7ByIMdXNlcl9pZGkBeyIKZmxhc2h7AA%3D%3D--bf9785a666d3c4ac09f7fe3353496b437546cfbf', { 'user_id' => 123, 'flash' => {} }] 
+    }
+  end
+  
+  
+  
+  it "should raise argument error if missing secret key" do
+    lambda { Merb::CookieStore.new(nil, nil) }.should raise_error(ArgumentError)
+  end
+  
+  it "should restore and unmarshal good cookies" do
+    cookies(:empty, :a_one, :typical).each do |value, expected|
+      session = Merb::CookieStore.new(value, @secret)
+      session['lazy loads the data hash'].should be_nil
+      session.data.should == expected
+    end
+  end
+  
+  it "should raise error on tampered cookie" do
+    lambda { Merb::CookieStore.new('a--b', @secret) }.should 
+      raise_error(Merb::CookieStore::TamperedWithCookie)
+  end
+  
+  it "should raise when data overflows" do
+    session =  Merb::CookieStore.new(cookie_value(:empty), @secret)
+    session['overflow'] = 'bye!' * 1024
+    lambda { session.read_cookie }.should 
+      raise_error(Merb::CookieStore::CookieOverflow)
+  end
+  
+  it "should close and marshal cookie data" do 
+    session =  Merb::CookieStore.new(cookie_value(:typical), @secret)
+    session.modified?.should == false
+    session['flash'] = {}
+    session.modified?.should == true
+    session.read_cookie.should == cookie_value(:flashed)
+  end
+  
+end