padrino-core 0.16.0.pre3 → 0.16.0

data/test/test_application.rb

@@ -1,61 +1,60 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
 class PadrinoPristine < Padrino::Application; end
 class PadrinoTestApp  < Padrino::Application; end
 class PadrinoTestApp2 < Padrino::Application; end
 
-describe "Application" do
+describe 'Application' do
   before { Padrino.clear! }
 
   describe 'for application functionality' do
-
     it 'should check default options' do
       assert File.identical?(__FILE__, PadrinoPristine.app_file)
       assert_equal :padrino_pristine, PadrinoPristine.app_name
       assert_equal :test, PadrinoPristine.environment
       assert_equal Padrino.root('views'), PadrinoPristine.views
-      assert  PadrinoPristine.raise_errors
-      assert !PadrinoPristine.logging
-      assert !PadrinoPristine.sessions
-      assert !PadrinoPristine.dump_errors
-      assert !PadrinoPristine.show_exceptions
-      assert  PadrinoPristine.raise_errors
-      assert !Padrino.configure_apps
+      assert PadrinoPristine.raise_errors
+      refute PadrinoPristine.logging
+      refute PadrinoPristine.sessions
+      refute PadrinoPristine.dump_errors
+      refute PadrinoPristine.show_exceptions
+      assert PadrinoPristine.raise_errors
+      refute Padrino.configure_apps
     end
 
     it 'should check padrino specific options' do
-      assert !PadrinoPristine.instance_variable_get(:@_configured)
+      refute PadrinoPristine.instance_variable_get(:@_configured)
       PadrinoPristine.send(:setup_application!)
       assert_equal :padrino_pristine, PadrinoPristine.app_name
       assert_equal 'StandardFormBuilder', PadrinoPristine.default_builder
-      assert  PadrinoPristine.instance_variable_get(:@_configured)
-      assert !PadrinoPristine.reload?
+      assert PadrinoPristine.instance_variable_get(:@_configured)
+      refute PadrinoPristine.reload?
     end
 
     it 'should set global project settings' do
-      Padrino.configure_apps { enable :sessions; set :foo, "bar" }
+      Padrino.configure_apps { enable :sessions; set :foo, 'bar' }
       PadrinoTestApp.send(:default_configuration!)
       PadrinoTestApp2.send(:default_configuration!)
-      assert PadrinoTestApp.sessions, "should have sessions enabled"
-      assert_equal "bar", PadrinoTestApp.settings.foo, "should have foo assigned"
+      assert PadrinoTestApp.sessions, 'should have sessions enabled'
+      assert_equal 'bar', PadrinoTestApp.settings.foo, 'should have foo assigned'
       assert_equal PadrinoTestApp.session_secret, PadrinoTestApp2.session_secret
     end
 
     it 'should be able to configure_apps multiple times' do
-      Padrino.configure_apps { set :foo1, "bar" }
-      Padrino.configure_apps { set :foo1, "bam" }
-      Padrino.configure_apps { set :foo2, "baz" }
+      Padrino.configure_apps { set :foo1, 'bar' }
+      Padrino.configure_apps { set :foo1, 'bam' }
+      Padrino.configure_apps { set :foo2, 'baz' }
       PadrinoTestApp.send(:default_configuration!)
-      assert_equal "bam", PadrinoTestApp.settings.foo1, "should have foo1 assigned to bam"
-      assert_equal "baz", PadrinoTestApp.settings.foo2, "should have foo2 assigned to baz"
+      assert_equal 'bam', PadrinoTestApp.settings.foo1, 'should have foo1 assigned to bam'
+      assert_equal 'baz', PadrinoTestApp.settings.foo2, 'should have foo2 assigned to baz'
     end
 
     it 'should have shared sessions accessible in project' do
       Padrino.configure_apps { enable :sessions; set :session_secret, PadrinoTestApp2.session_secret }
-      Padrino.mount("PadrinoTestApp").to("/write")
-      Padrino.mount("PadrinoTestApp2").to("/read")
+      Padrino.mount('PadrinoTestApp').to('/write')
+      Padrino.mount('PadrinoTestApp2').to('/read')
       PadrinoTestApp.send :default_configuration!
-      PadrinoTestApp.get('/') { session[:foo] = "shared" }
+      PadrinoTestApp.get('/') { session[:foo] = 'shared' }
       PadrinoTestApp2.send(:default_configuration!)
       PadrinoTestApp2.get('/') { session[:foo] }
       @app = Padrino.application
@@ -73,10 +72,10 @@ describe "Application" do
 
     it 'should able to set custome session management' do
       class PadrinoTestApp3 < Padrino::Application
-        set :sessions, :use => Rack::Session::Pool
+        set :sessions, use: Rack::Session::Pool
       end
-      Padrino.mount("PadrinoTestApp3").to("/")
-      PadrinoTestApp3.get('/write') { session[:foo] = "pool" }
+      Padrino.mount('PadrinoTestApp3').to('/')
+      PadrinoTestApp3.get('/write') { session[:foo] = 'pool' }
       PadrinoTestApp3.get('/read') { session[:foo] }
       @app = Padrino.application
       get '/write'
@@ -88,12 +87,14 @@ describe "Application" do
       class PadrinoTestApp4 < Padrino::Application
         enable :sessions
       end
+
       class PadrinoTestApp5 < Padrino::Application
-        set :sessions, :use => Rack::Session::Pool
+        set :sessions, use: Rack::Session::Pool
       end
-      Padrino.mount("PadrinoTestApp4").to("/write")
-      Padrino.mount("PadrinoTestApp5").to("/read")
-      PadrinoTestApp4.get('/') { session[:foo] = "cookie" }
+
+      Padrino.mount('PadrinoTestApp4').to('/write')
+      Padrino.mount('PadrinoTestApp5').to('/read')
+      PadrinoTestApp4.get('/') { session[:foo] = 'cookie' }
       PadrinoTestApp5.get('/') { session[:foo] }
       @app = Padrino.application
       get '/write'
@@ -106,8 +107,8 @@ describe "Application" do
       mock_app do
         provides :xml
 
-        get("/foo"){ "Foo in #{content_type.inspect}" }
-        get("/bar"){ "Foo in #{content_type.inspect}" }
+        get('/foo') { "Foo in #{content_type.inspect}" }
+        get('/bar') { "Foo in #{content_type.inspect}" }
       end
 
       get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
@@ -116,61 +117,59 @@ describe "Application" do
       assert_equal 'Foo in :xml', body
 
       get '/bar', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-      assert_equal "Foo in nil", body
+      assert_equal 'Foo in nil', body
     end
 
     it 'should resolve views and layouts paths' do
-      assert_equal Padrino.root('views')+'/users/index', PadrinoPristine.view_path('users/index')
-      assert_equal Padrino.root('views')+'/layouts/app', PadrinoPristine.layout_path(:app)
+      assert_equal "#{Padrino.root('views')}/users/index", PadrinoPristine.view_path('users/index')
+      assert_equal "#{Padrino.root('views')}/layouts/app", PadrinoPristine.layout_path(:app)
     end
 
-    describe "errors" do
+    describe 'errors' do
       it 'should have not mapped errors on development' do
-        mock_app { get('/'){ 'HI' } }
-        get "/"
+        mock_app { get('/') { 'HI' } }
+        get '/'
         assert_empty @app.errors
       end
 
       it 'should have mapped errors on production' do
-        mock_app { set :environment, :production; get('/'){ 'HI' } }
-        get "/"
+        mock_app { set :environment, :production; get('/') { 'HI' } }
+        get '/'
         assert_equal 1, @app.errors.size
       end
 
       it 'should overide errors' do
         mock_app do
           set :environment, :production
-          get('/'){ raise }
-          error(::Exception){ 'custom error' }
+          get('/') { raise }
+          error(::Exception) { 'custom error' }
         end
-        get "/"
+        get '/'
         assert_equal 1, @app.errors.size
         assert_equal 'custom error', body
       end
 
+      # see naming collision in issue #1814
       it 'should pass Routing#parent to Module#parent' do
-        # see naming collision in issue #1814
-        
-          ConstTest = Class.new(Padrino::Application)
-          class Module
-            def parent
-              :dirty
-            end
+        ConstTest = Class.new(Padrino::Application)
+        class Module
+          def parent
+            :dirty
           end
-          assert_equal :dirty, ConstTest.parent
-        ensure
-          Module.instance_eval{ undef :parent }
-        
+        end
+        assert_equal :dirty, ConstTest.parent
+      ensure
+        Module.instance_eval { undef :parent }
       end
     end
 
-    describe "pre-compile routes" do
-      it "should compile routes before first request if enabled the :precompile_routes option" do
-        require File.expand_path(File.dirname(__FILE__) + '/fixtures/apps/precompiled_app')
+    describe 'pre-compile routes' do
+      it 'should compile routes before first request if enabled the :precompile_routes option' do
+        require File.expand_path("#{__dir__}/fixtures/apps/precompiled_app")
         assert_instance_of Padrino::PathRouter::Compiler, PrecompiledApp::App.compiled_router.engine
         assert_instance_of Padrino::PathRouter::Compiler, PrecompiledApp::SubApp.compiled_router.engine
-        assert_equal true, PrecompiledApp::App.compiled_router.engine.compiled?
-        assert_equal true, PrecompiledApp::SubApp.compiled_router.engine.compiled?
+        assert PrecompiledApp::App.compiled_router.engine.compiled?
+        assert PrecompiledApp::SubApp.compiled_router.engine.compiled?
         assert_equal 20, PrecompiledApp::App.compiled_router.engine.routes.length
         assert_equal 20, PrecompiledApp::SubApp.compiled_router.engine.routes.length
       end

data/test/test_configuration.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
-describe "PadrinoConfiguration" do
+describe 'PadrinoConfiguration' do
   it 'should be able to store values' do
     Padrino.config.val1 = 12_345
     assert_equal 12_345, Padrino.config.val1

data/test/test_core.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
-describe "Core" do
+describe 'Core' do
   def setup
     Padrino.clear!
   end
@@ -19,7 +19,7 @@ describe "Core" do
 
     it 'should validate global helpers' do
       assert_equal :test, Padrino.env
-      assert_match(/\/test/, Padrino.root)
+      assert_match(%r{/test}, Padrino.root)
       assert Padrino.version
     end
 
@@ -38,25 +38,25 @@ describe "Core" do
     end
 
     it 'should add middlewares in front if specified' do
-      test = Class.new {
+      test = Class.new do
         def initialize(app)
           @app = app
         end
 
         def call(env)
           status, headers, body = @app.call(env)
-          headers["Middleware-Called"] = "yes"
+          headers['Middleware-Called'] = 'yes'
           [status, headers, body]
         end
-      }
+      end
 
       class Foo < Padrino::Application; end
 
       Padrino.use(test)
-      Padrino.mount(Foo).to("/")
+      Padrino.mount(Foo).to('/')
 
-      res = Rack::MockRequest.new(Padrino.application).get("/")
-      assert_equal "yes", res["Middleware-Called"]
+      res = Rack::MockRequest.new(Padrino.application).get('/')
+      assert_equal 'yes', res['Middleware-Called']
     end
 
     it 'should properly set default options' do
@@ -75,13 +75,13 @@ describe "Core" do
     it 'should return a friendly 500' do
       mock_app do
         enable :show_exceptions
-        get(:index){ raise StandardError }
+        get(:index) { raise StandardError }
       end
 
-      get "/"
+      get '/'
       assert_equal 500, status
-      assert_includes body, "StandardError"
-      assert_includes body, "<code>show_exceptions</code> setting"
+      assert_includes body, 'StandardError'
+      assert_includes body, '<code>show_exceptions</code> setting'
     end
   end
 end

data/test/test_csrf_protection.rb

@@ -1,206 +1,210 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
-describe "Application" do
+describe 'Application' do
   before { Padrino.clear! }
 
   describe 'CSRF protection' do
-    describe "with CSRF protection on" do
+    describe 'with CSRF protection on' do
       before do
-        @token = begin
-                   Rack::Protection::AuthenticityToken.random_token
-                 rescue StandardError
-                   "a_token"
-                 end
+        @token =
+          begin
+            Rack::Protection::AuthenticityToken.random_token
+          rescue StandardError
+            'a_token'
+          end
+
         mock_app do
           enable :sessions
           enable :protect_from_csrf
-          post('/'){ 'HI' }
+          post('/') { 'HI' }
         end
       end
 
       it 'should not allow requests without tokens' do
-        post "/"
+        post '/'
         assert_equal 403, status
       end
 
       it 'should allow requests with correct tokens' do
-        post "/", {"authenticity_token" => @token}, 'rack.session' => {:csrf => @token}
+        post '/', { 'authenticity_token' => @token }, 'rack.session' => { csrf: @token }
         assert_equal 200, status
       end
 
       it 'should not allow requests with incorrect tokens' do
-        post "/", {"authenticity_token" => "b"}, 'rack.session' => {:csrf => @token}
+        post '/', { 'authenticity_token' => 'b' }, 'rack.session' => { csrf: @token }
         assert_equal 403, status
       end
 
       it 'should allow requests with correct X-CSRF-TOKEN' do
-        post "/", {}, 'rack.session' => {:csrf => @token}, 'HTTP_X_CSRF_TOKEN' => @token
+        post '/', {}, 'rack.session' => { csrf: @token }, 'HTTP_X_CSRF_TOKEN' => @token
         assert_equal 200, status
       end
 
       it 'should not allow requests with incorrect X-CSRF-TOKEN' do
-        post "/", {}, 'rack.session' => {:csrf => @token}, 'HTTP_X_CSRF_TOKEN' => "b"
+        post '/', {}, 'rack.session' => { csrf: @token }, 'HTTP_X_CSRF_TOKEN' => 'b'
         assert_equal 403, status
       end
     end
 
-    describe "without CSRF protection on" do
+    describe 'without CSRF protection on' do
       before do
         mock_app do
           enable :sessions
           disable :protect_from_csrf
-          post('/'){ 'HI' }
+          post('/') { 'HI' }
         end
       end
 
       it 'should allows requests without tokens' do
-        post "/"
+        post '/'
         assert_equal 200, status
       end
 
       it 'should allow requests with correct tokens' do
-        post "/", {"authenticity_token" => "a"}, 'rack.session' => {:csrf => "a"}
+        post '/', { 'authenticity_token' => 'a' }, 'rack.session' => { csrf: 'a' }
         assert_equal 200, status
       end
 
       it 'should allow requests with incorrect tokens' do
-        post "/", {"authenticity_token" => "a"}, 'rack.session' => {:csrf => "b"}
+        post '/', { 'authenticity_token' => 'a' }, 'rack.session' => { csrf: 'b' }
         assert_equal 200, status
       end
 
       it 'should allow requests with correct X-CSRF-TOKEN' do
-        post "/", {}, 'rack.session' => {:csrf => "a"}, 'HTTP_X_CSRF_TOKEN' => "a"
+        post '/', {}, 'rack.session' => { csrf: 'a' }, 'HTTP_X_CSRF_TOKEN' => 'a'
         assert_equal 200, status
       end
 
       it 'should allow requests with incorrect X-CSRF-TOKEN' do
-        post "/", {}, 'rack.session' => {:csrf => "a"}, 'HTTP_X_CSRF_TOKEN' => "b"
+        post '/', {}, 'rack.session' => { csrf: 'a' }, 'HTTP_X_CSRF_TOKEN' => 'b'
         assert_equal 200, status
       end
     end
 
-    describe "with optional CSRF protection" do
+    describe 'with optional CSRF protection' do
       before do
         mock_app do
           enable :sessions
           enable :protect_from_csrf
           enable :allow_disabled_csrf
           post('/on') { 'HI' }
-          post('/off', :csrf_protection => false) { 'HI' }
+          post('/off', csrf_protection: false) { 'HI' }
         end
       end
 
       it 'should allow access to routes with csrf_protection off' do
-        post "/off"
+        post '/off'
         assert_equal 200, status
       end
 
       it 'should not allow access to routes with csrf_protection on' do
-        post "/on"
+        post '/on'
         assert_equal 403, status
         assert_equal 'Forbidden', body
       end
     end
 
-    describe "with :except option that is using Proc" do
+    describe 'with :except option that is using Proc' do
       before do
         mock_app do
           enable :sessions
-          set :protect_from_csrf, :except => proc{|env| ["/", "/foo"].any?{|path| path == env['PATH_INFO'] }}
-          post("/") { "Hello" }
-          post("/foo") { "Hello, foo" }
-          post("/bar") { "Hello, bar" }
+          set :protect_from_csrf, except: proc { |env| ['/', '/foo'].any? { |path| path == env['PATH_INFO'] } }
+          post('/') { 'Hello' }
+          post('/foo') { 'Hello, foo' }
+          post('/bar') { 'Hello, bar' }
         end
       end
 
       it 'should allow ignoring CSRF protection on specific routes' do
-        post "/"
+        post '/'
         assert_equal 200, status
-        post "/foo"
+        post '/foo'
         assert_equal 200, status
-        post "/bar"
+        post '/bar'
         assert_equal 403, status
       end
     end
 
-    describe "with :except option that is using String and Regexp" do
+    describe 'with :except option that is using String and Regexp' do
       before do
         mock_app do
           enable :sessions
-          set :protect_from_csrf, :except => ["/a", %r{^/a.c$}]
-          post("/a") { "a" }
-          post("/abc") { "abc" }
-          post("/foo") { "foo" }
+          set :protect_from_csrf, except: ['/a', %r{^/a.c$}]
+          post('/a') { 'a' }
+          post('/abc') { 'abc' }
+          post('/foo') { 'foo' }
         end
       end
 
       it 'should allow ignoring CSRF protection on specific routes' do
-        post "/a"
+        post '/a'
         assert_equal 200, status
-        post "/abc"
+        post '/abc'
         assert_equal 200, status
-        post "/foo"
+        post '/foo'
         assert_equal 403, status
       end
     end
 
-    describe "with custom protection options" do
+    describe 'with custom protection options' do
       before do
-        @token = begin
-                   Rack::Protection::AuthenticityToken.random_token
-                 rescue StandardError
-                   "a_token"
-                 end
+        @token =
+          begin
+            Rack::Protection::AuthenticityToken.random_token
+          rescue StandardError
+            'a_token'
+          end
+
         mock_app do
           enable :sessions
-          set :protect_from_csrf, :authenticity_param => 'foobar', :message => 'sucker!'
-          post("/a") { "a" }
+          set :protect_from_csrf, authenticity_param: 'foobar', message: 'sucker!'
+          post('/a') { 'a' }
         end
       end
 
       it 'should allow configuring protection options' do
-        post "/a", {"foobar" => @token}, 'rack.session' => {:csrf => @token}
+        post '/a', { 'foobar' => @token }, 'rack.session' => { csrf: @token }
         assert_equal 200, status
       end
 
       it 'should allow configuring message' do
-        post "/a"
+        post '/a'
         assert_equal 403, status
         assert_equal 'sucker!', body
       end
     end
 
-    describe "with middleware" do
+    describe 'with middleware' do
       before do
         class Middleware < Sinatra::Base
-          post("/middleware") { "Hello, middleware" }
-          post("/dummy") { "Hello, dummy" }
+          post('/middleware') { 'Hello, middleware' }
+          post('/dummy') { 'Hello, dummy' }
         end
         mock_app do
           enable :sessions
-          set :protect_from_csrf, :except => proc{|env| ["/", "/middleware"].any?{|path| path == env['PATH_INFO'] }}
+          set :protect_from_csrf, except: proc { |env| ['/', '/middleware'].any? { |path| path == env['PATH_INFO'] } }
           use Middleware
-          post("/") { "Hello" }
+          post('/') { 'Hello' }
         end
       end
 
       it 'should allow ignoring CSRF protection on specific routes of middleware' do
-        post "/"
+        post '/'
         assert_equal 200, status
-        post "/middleware"
+        post '/middleware'
         assert_equal 200, status
-        post "/dummy"
+        post '/dummy'
         assert_equal 403, status
       end
     end
 
-    describe "with standard report layout" do
+    describe 'with standard report layout' do
       before do
         mock_app do
           enable :sessions
-          set :protect_from_csrf, :message => 'sucker!'
+          set :protect_from_csrf, message: 'sucker!'
           enable :report_csrf_failure
-          post("/a") { "a" }
+          post('/a') { 'a' }
           error 403 do
             halt 406, 'please, do not hack'
           end
@@ -208,7 +212,7 @@ describe "Application" do
       end
 
       it 'should allow configuring protection options' do
-        post "/a"
+        post '/a'
         assert_equal 406, status
         assert_equal 'please, do not hack', body
       end