merb 0.5.3 → 0.9.2

data/spec/merb/config_spec.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Merb::Config do
-  before(:all) do
-    @config_yml = File.expand_path(File.dirname(__FILE__) / ".." / "fixtures")
-  end
-  
-  it "should have a default configuration" do
-    Merb::Config.defaults.should be_is_a(Hash)
-    Merb::Config.defaults[:merb_root].should == Dir.pwd
-  end
-  
-  it "should not load the config.yml file if it does not exist" do
-    Merb::Config.setup.should be_is_a(Hash)
-    Merb::Config.setup.should == Merb::Config.defaults
-  end
-  
-  it "should load the config.yml file if it exists" do
-    Merb::Config.defaults.merge!(:merb_root => @config_yml)
-    Merb::Config.setup.should be_is_a(Hash)
-    Merb::Config.setup[:host].should == "127.0.0.1"
-  end
-
-  it "should accept erb in the config.yml file" do
-    Merb::Config.defaults.merge!(:merb_root => @config_yml)
-    Merb::Config.setup.should be_is_a(Hash)
-    Merb::Config.setup[:environment].should == "test"
-  end
-end

data/spec/merb/controller_filters_spec.rb

@@ -1,253 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-class TestFiltersController < Merb::Controller
-  
-  before :filter1
-  before :will_halt, :only => :four
-  
-  before :overwrite_before_filter, :only => :two
-  after  :overwrite_after_filter, :exclude => :four
-  
-  after  :after_will_be_skipped
-  before :before_will_be_skipped
-
-  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
-
-  before :overwrite_before_filter, :only => :three
-  after  :overwrite_after_filter, :exclude => [:one, :two, :uses_param]
-
-  skip_before :before_will_be_skipped
-  skip_after  :after_will_be_skipped
-  
-  # filters
-  
-  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 before_will_be_skipped
-    @before_skip='called'
-  end
-  
-  def after_will_be_skipped
-    @after_skip='called'
-  end
-  
-  def overwrite_before_filter
-    @overwrite_before_filter='called'
-  end
-  
-  def overwrite_after_filter
-    @overwrite_after_filter='called'    
-  end
-  
-  # actions
-  
-  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(Merb::Cookies) 
-    @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
-  
-  it "should be overwritten by a subsequent call with the same filter" do
-    c = new_controller( 'two', TestFiltersController )
-    c.dispatch(:two)
-    c.body.should == 'two'
-    c.instance_variable_get('@overwrite_before_filter').should == nil
-    c.instance_variable_get('@overwrite_after_filter').should == nil    
-    
-    c = new_controller( 'three', TestFiltersController )
-    c.dispatch(:three)
-    c.body.should == 'three'
-    c.instance_variable_get('@overwrite_before_filter').should == 'called'
-    c.instance_variable_get('@overwrite_after_filter').should == 'called'
-  end
-  
-  it "should not run if skipped" 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('@before_skip').should == nil
-    c.instance_variable_get('@after_skip').should == nil    
-  end
-  
-  it "should not allow skipping a filter that is not a symbol or string" do
-    ["before", "after"].each do |filter_type|    
-      lambda { TestFiltersController.send('skip_'+filter_type, Proc.new{|c|puts c}) }.should raise_error(ArgumentError)
-    end
-  end
-
-end

data/spec/merb/controller_spec.rb

@@ -1,126 +0,0 @@
-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
-
-  it "should have a spec helper to dispatch that skips the router" do
-    Merb::Router.should_not_receive(:match)
-    dispatch_to(Bar, :foo, :id => "1") do |controller|
-      if defined? ParseTreeArray # We have parameterized actions
-        controller.should_receive(:foo).with("1")
-      else
-        controller.should_receive(:foo) # No parameterized actions
-        controller.params[:id].should == "1"
-      end
-    end
-  end
-  
-end
-
-describe Merb::Controller, "url generator tests" do
-  
-  it_should_behave_like "class with general url generation"
-  
-  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
-
-  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 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 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
-end
-
-describe "Controller", "redirect spec helpers" do
-  class Redirector < Merb::Controller
-    def index
-      redirect("/foo")
-    end
-    def show
-    end
-    def permanent
-      redirect("/foo",:permanent)
-    end
-  end
-  
-  before(:each) do
-    @controller = Redirector.build(fake_request)
-  end
-  
-  it "should be able to match redirects" do
-    @controller.dispatch('index')
-    @controller.status.should be_redirect
-    @controller.should redirect
-    @controller.should redirect_to("/foo")
-  end
-  
-  it "should be able to negative match redirects" do
-    @controller.dispatch('show')
-    @controller.status.should_not be_redirect
-    @controller.should_not redirect
-    @controller.should_not redirect_to("/foo")
-  end
-  
-  it "should be able to match permanent redirects" do
-    @controller.dispatch('permanent')
-    @controller.status.should be_redirect
-    @controller.should redirect
-    @controller.should redirect_to("/foo")
-  end
-end

data/spec/merb/cookie_store_spec.rb

@@ -1,72 +0,0 @@
-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::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'].each {|c| c.should =~ %r{_session_id=} }# this could be better
-  end
-end
-
-describe Merb::CookieStore do
-  
-  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.values_at(: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(@cookies[:empty].first, @secret)
-    session['overflow'] = 'bye!' * 1024
-    lambda { session.read_cookie }.should 
-      raise_error(Merb::CookieStore::CookieOverflow)
-  end
-
-  it "should delete entries in the session" do
-    session = Merb::CookieStore.new(@cookies[:a_one].first, @secret)
-    session.delete('a').should == 1
-  end
-  
-end