padrino-core 0.9.29 → 0.10.0

data/test/fixtures/apps/simple.rb

@@ -18,7 +18,7 @@ SimpleDemo.controllers do
   end
 
   get "/rand" do
-    rand(99).to_s
+    rand(2 ** 256).to_s
   end
 end
 

data/test/fixtures/dependencies/circular/e.rb

@@ -0,0 +1,13 @@
+class E
+  def self.fields
+    @fields ||= []
+  end
+
+  def self.inherited(subclass)
+    subclass.fields.replace fields.dup
+  end
+
+  G
+
+  fields << "name"
+end

data/test/fixtures/dependencies/circular/f.rb

@@ -0,0 +1,2 @@
+class F < E
+end

data/test/fixtures/dependencies/circular/g.rb

@@ -0,0 +1,2 @@
+class G
+end

data/test/helper.rb

@@ -9,6 +9,10 @@ require 'rack'
 require 'shoulda'
 require 'phocus'
 
+# Rubies < 1.9 don't handle hashes in the properly order so to prevent
+# this issue for now we remove extra values from mimetypes.
+Rack::Mime::MIME_TYPES.delete(".xsl") # In this way application/xml respond only to .xml
+
 module Kernel
   # Silences the output by redirecting to stringIO
   # silence_logger { ...commands... } => "...output..."
@@ -25,8 +29,7 @@ module Kernel
     yield
   ensure
     $VERBOSE = old_verbose
-  end unless respond_to?(:silence_warnings)
-
+  end
 end
 
 class Class

data/test/test_core.rb

@@ -33,7 +33,7 @@ class TestCore < Test::Unit::TestCase
         assert_equal 'UTF8', $KCODE
       else
         assert_equal Encoding.default_external, Encoding::UTF_8
-        assert_equal Encoding.default_internal, Encoding::UTF_8
+        assert_equal Encoding.default_internal, nil # Encoding::UTF_8
       end
     end
 

data/test/test_dependencies.rb

@@ -28,5 +28,17 @@ class TestDependencies < Test::Unit::TestCase
       assert_equal ["B", "C"], A_result
       assert_equal "C", B_result
     end
+
+    should 'remove partially loaded constants' do
+      silence_warnings do
+        Padrino.require_dependencies(
+          Padrino.root("fixtures/dependencies/circular/e.rb"),
+          Padrino.root("fixtures/dependencies/circular/f.rb"),
+          Padrino.root("fixtures/dependencies/circular/g.rb")
+        )
+      end
+
+      assert_equal ["name"], F.fields
+    end
   end
-end
+end

data/test/test_filters.rb

@@ -0,0 +1,266 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class TestFilters < Test::Unit::TestCase
+  should "filters by accept header" do
+    mock_app do
+      get '/foo', :provides => [:xml, :js] do
+        request.env['HTTP_ACCEPT']
+      end
+    end
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+    assert ok?
+    assert_equal 'application/xml', body
+    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo.xml'
+    assert ok?
+    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/javascript' }
+    assert ok?
+    assert_equal 'application/javascript', body
+    assert_equal 'application/javascript;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo.js'
+    assert ok?
+    assert_equal 'application/javascript;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo', {}, { "HTTP_ACCEPT" => 'text/html' }
+    assert_equal 406, status
+  end
+
+  should "allow passing & halting in before filters" do
+    mock_app do
+      controller do
+        before { env['QUERY_STRING'] == 'secret' or pass }
+        get :index do
+          "secret index"
+        end
+      end
+
+      controller do
+        before { env['QUERY_STRING'] == 'halt' and halt 401, 'go away!' }
+        get :index do
+          "index"
+        end
+      end
+    end
+
+    get "/?secret"
+    assert_equal "secret index", body
+
+    get "/?halt"
+    assert_equal "go away!", body
+    assert_equal 401, status
+
+    get "/"
+    assert_equal "index", body
+  end
+
+  should 'scope filters in the given controller' do
+    mock_app do
+      before { @global = 'global' }
+      after { @global = nil }
+
+      controller :foo do
+        before { @foo = :foo }
+        after { @foo = nil }
+        get("/") { [@foo, @bar, @global].compact.join(" ") }
+      end
+
+      get("/") { [@foo, @bar, @global].compact.join(" ") }
+
+      controller :bar do
+        before { @bar = :bar }
+        after { @bar = nil }
+        get("/") { [@foo, @bar, @global].compact.join(" ") }
+      end
+    end
+
+    get "/bar"
+    assert_equal "bar global", body
+
+    get "/foo"
+    assert_equal "foo global", body
+
+    get "/"
+    assert_equal "global", body
+  end
+
+  should 'be able to access params in a before filter' do
+    username_from_before_filter = nil
+
+    mock_app do
+      before do
+        username_from_before_filter = params[:username]
+      end
+
+      get :users, :with => :username do
+      end
+    end
+    get '/users/josh'
+    assert_equal 'josh', username_from_before_filter
+  end
+
+  should "be able to access params normally when a before filter is specified" do
+    mock_app do
+      before { }
+      get :index do
+        params.inspect
+      end
+    end
+    get '/?test=what'
+    assert_equal '{"test"=>"what"}', body
+  end
+
+  should "be able to filter based on a path" do
+    mock_app do
+      before('/') { @test = "#{@test}before"}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal '', body
+  end
+
+  should "be able to filter based on a symbol" do
+    mock_app do
+      before(:index) { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal '', body
+  end
+
+  should "be able to filter based on a symbol for a controller" do
+    mock_app do
+      controller :foo do
+        before(:test) { @test = 'foo'}
+        get :test do
+          @test.to_s + " response"
+        end
+      end
+      controller :bar do
+        before(:test) { @test = 'bar'}
+        get :test do
+          @test.to_s + " response"
+        end
+      end
+    end
+    get '/foo/test'
+    assert_equal 'foo response', body
+    get '/bar/test'
+    assert_equal 'bar response', body
+  end
+
+  should "be able to filter based on a symbol or path" do
+    mock_app do
+      before(:index, '/main') { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal 'before', body
+  end
+
+  should "be able to filter based on a symbol or regexp" do
+    mock_app do
+      before(:index, /main/) { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+      get :profile do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal 'before', body
+    get '/profile'
+    assert_equal '', body
+  end
+
+  should "be able to filter excluding based on a symbol" do
+    mock_app do
+      before(:except => :index) { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal '', body
+    get '/main'
+    assert_equal 'before', body
+  end
+
+  should "be able to filter based on a request param" do
+    mock_app do
+      before(:agent => /IE/) { @test = 'before'}
+      get :index do
+        @test
+      end
+    end
+    get '/'
+    assert_equal '', body
+    get "/", {}, {'HTTP_USER_AGENT' => 'This is IE'}
+    assert_equal 'before', body
+  end
+
+  should "be able to filter based on a symbol or path in multiple controller" do
+    mock_app do
+      controllers :foo do
+        before(:index, '/foo/main') { @test = 'before' }
+        get :index do
+          @test
+        end
+        get :main do
+          @test
+        end
+      end
+      controllers :bar do
+        before(:index, '/bar/main') { @test = 'also before' }
+        get :index do
+          @test
+        end
+        get :main do
+          @test
+        end
+      end
+    end
+    get '/foo'
+    assert_equal 'before', body
+    get '/bar'
+    assert_equal 'also before', body
+    get '/foo/main'
+    assert_equal 'before', body
+    get '/bar/main'
+    assert_equal 'also before', body
+  end
+end

data/test/test_rendering.rb

@@ -2,6 +2,10 @@ require File.expand_path(File.dirname(__FILE__) + '/helper')
 require 'i18n'
 
 class TestRendering < Test::Unit::TestCase
+  def setup
+    Padrino::Application.send(:register, Padrino::Rendering)
+  end
+
   def teardown
     remove_views
   end
@@ -368,7 +372,7 @@ class TestRendering < Test::Unit::TestCase
       assert_equal "Im Italian Js", body
       I18n.locale = :en
       get "/foo.pk"
-      assert_equal 404, status
+      assert_equal 405, status
     end
 
     should 'resolve template content_type and locale with layout' do
@@ -410,7 +414,7 @@ class TestRendering < Test::Unit::TestCase
       get "/bar.json"
       assert_equal "Im a json", body
       get "/bar.pk"
-      assert_equal 404, status
+      assert_equal 405, status
     end
 
     should 'renders erb with blocks' do

data/test/test_routing.rb

@@ -101,9 +101,9 @@ class TestRouting < Test::Unit::TestCase
       post("/main"){ "hello" }
     end
     assert_equal 3, app.routes.size, "should generate GET, HEAD and PUT"
-    assert_equal ["GET"],  app.routes[0].as_options[:conditions][:request_method]
-    assert_equal ["HEAD"], app.routes[1].as_options[:conditions][:request_method]
-    assert_equal ["POST"], app.routes[2].as_options[:conditions][:request_method]
+    assert_equal ["GET"],  app.routes[0].conditions[:request_method]
+    assert_equal ["HEAD"], app.routes[1].conditions[:request_method]
+    assert_equal ["POST"], app.routes[2].conditions[:request_method]
   end
 
   should 'generate basic urls' do
@@ -155,13 +155,13 @@ class TestRouting < Test::Unit::TestCase
     get "/b.js"
     assert_equal "/b.js", body
     get "/b.ru"
-    assert_equal 404, status
+    assert_equal 405, status
     get "/c.js"
     assert_equal "/c.json", body
     get "/c.json"
     assert_equal "/c.json", body
     get "/c.ru"
-    assert_equal 404, status
+    assert_equal 405, status
     get "/d"
     assert_equal "/d.js?foo=bar", body
     get "/d.js"
@@ -218,7 +218,7 @@ class TestRouting < Test::Unit::TestCase
     end
 
     get "/a.xml", {}, {}
-    assert_equal 404, status
+    assert_equal 405, status
   end
 
   should "not set content_type to :html if Accept */* and html not in provides" do
@@ -288,7 +288,7 @@ class TestRouting < Test::Unit::TestCase
     end
 
     get "/a.xml", {}, {"HTTP_ACCEPT" => "text/html"}
-    assert_equal 404, status
+    assert_equal 405, status
   end
 
   should "generate routes for format simple" do
@@ -634,12 +634,36 @@ class TestRouting < Test::Unit::TestCase
   should 'reset routes' do
     mock_app do
       get("/"){ "foo" }
-      router.reset!
+      reset_router!
     end
     get "/"
     assert_equal 404, status
   end
 
+  should 'respect priorities' do
+    route_order = []
+    mock_app do
+      get(:index, :priority => :normal) { route_order << :normal; pass }
+      get(:index, :priority => :low)  { route_order << :low; "hello" }
+      get(:index, :priority => :high)  { route_order << :high; pass }
+    end
+    get '/'
+    assert_equal [:high, :normal, :low], route_order
+    assert_equal "hello", body
+  end
+
+  should 'allow optionals' do
+    mock_app do
+      get(:show, :map => "/stories/:type(/:category)") do
+        "#{params[:type]}/#{params[:category]}"
+      end
+    end
+    get "/stories/foo"
+    assert_equal "foo/", body
+    get "/stories/foo/bar"
+    assert_equal "foo/bar", body
+  end
+
   should 'apply maps' do
     mock_app do
       controllers :admin do
@@ -1151,11 +1175,11 @@ class TestRouting < Test::Unit::TestCase
     get "/.json"
     assert_equal "This is the get index.json", body
     get "/.js"
-    assert_equal 404, status
+    assert_equal 405, status
     post "/.json"
     assert_equal "This is the post index.json", body
     post "/.js"
-    assert_equal 404, status
+    assert_equal 405, status
   end
 
   should "allow controller level mapping" do
@@ -1276,6 +1300,46 @@ class TestRouting < Test::Unit::TestCase
     assert_equal "foo", body
   end
 
+  should "pass controller conditions to each route" do
+    counter = 0
+
+    mock_app do
+      self.class.send(:define_method, :increment!) do |*args|
+        condition { counter += 1 }
+      end
+
+      controller :posts, :conditions => {:increment! => true} do
+        get("/foo") { "foo" }
+        get("/bar") { "bar" }
+      end
+
+    end
+
+    get "/posts/foo"
+    get "/posts/bar"
+    assert_equal 2, counter
+  end
+
+  should "allow controller conditions to be overridden" do
+    counter = 0
+
+    mock_app do
+      self.class.send(:define_method, :increment!) do |increment|
+        condition { counter += 1 } if increment
+      end
+
+      controller :posts, :conditions => {:increment! => true} do
+        get("/foo") { "foo" }
+        get("/bar", :increment! => false) { "bar" }
+      end
+
+    end
+
+    get "/posts/foo"
+    get "/posts/bar"
+    assert_equal 1, counter
+  end
+
   should "parse params with class level provides" do
     mock_app do
       controllers :posts, :provides => [:html, :js] do
@@ -1352,12 +1416,12 @@ class TestRouting < Test::Unit::TestCase
 
   should 'parse nested params' do
     mock_app do
-      get(:index) { params.inspect }
+      get(:index) { "%s %s" % [params[:account][:name], params[:account][:surname]] }
     end
     get "/?account[name]=foo&account[surname]=bar"
-    assert_equal '{"account"=>{"name"=>"foo", "surname"=>"bar"}}', body
+    assert_equal 'foo bar', body
     get @app.url(:index, "account[name]" => "foo", "account[surname]" => "bar")
-    assert_equal '{"account"=>{"name"=>"foo", "surname"=>"bar"}}', body
+    assert_equal 'foo bar', body
   end
 
   should 'render sinatra NotFound page' do
@@ -1424,4 +1488,4 @@ class TestRouting < Test::Unit::TestCase
     get @app.url(:index, :page => 10)
     assert_equal "/paginate/66", body
   end
-end
+end