sinatra-contrib 1.4.7 → 2.0.0.beta1

data/spec/reloader_spec.rb

@@ -88,31 +88,31 @@ describe Sinatra::Reloader do
     end
 
     it "doesn't mess up the application" do
-      get('/foo').body.should == 'foo'
+      expect(get('/foo').body).to eq('foo')
     end
 
     it "knows when a route has been modified" do
       update_app_file(:routes => ['get("/foo") { "bar" }'])
-      get('/foo').body.should == 'bar'
+      expect(get('/foo').body).to eq('bar')
     end
 
     it "knows when a route has been added" do
       update_app_file(
         :routes => ['get("/foo") { "foo" }', 'get("/bar") { "bar" }']
       )
-      get('/foo').body.should == 'foo'
-      get('/bar').body.should == 'bar'
+      expect(get('/foo').body).to eq('foo')
+      expect(get('/bar').body).to eq('bar')
     end
 
     it "knows when a route has been removed" do
       update_app_file(:routes => ['get("/bar") { "bar" }'])
-      get('/foo').status.should == 404
+      expect(get('/foo').status).to eq(404)
     end
 
     it "doesn't try to reload a removed file" do
       update_app_file(:routes => ['get("/foo") { "i shall not be reloaded" }'])
       FileUtils.rm app_file_path
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
     end
   end
 
@@ -125,7 +125,7 @@ describe Sinatra::Reloader do
     end
 
     it "doesn't mess up the application" do
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
     end
 
     it "reloads inline templates in the app file" do
@@ -133,7 +133,7 @@ describe Sinatra::Reloader do
         :routes => ['get("/foo") { erb :foo }'],
         :inline_templates => { :foo => 'bar' }
       )
-      get('/foo').body.strip.should == 'bar'
+      expect(get('/foo').body.strip).to eq('bar')
     end
 
     it "reloads inline templates in other file" do
@@ -144,11 +144,11 @@ describe Sinatra::Reloader do
       end
       require template_file_path
       app_const.inline_templates= template_file_path
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
       update_file(template_file_path) do |f|
         f.write "__END__\n\n@@foo\nbar"
       end
-      get('/foo').body.strip.should == 'bar'
+      expect(get('/foo').body.strip).to eq('bar')
     end
   end
 
@@ -160,7 +160,7 @@ describe Sinatra::Reloader do
         :middlewares => [Rack::Head]
       )
       get('/foo') # ...to perform the reload
-      app_const.middleware.should_not be_empty
+      expect(app_const.middleware).not_to be_empty
     end
 
     it "knows when a middleware has been removed" do
@@ -170,7 +170,7 @@ describe Sinatra::Reloader do
       )
       update_app_file(:routes => ['get("/foo") { "foo" }'])
       get('/foo') # ...to perform the reload
-      app_const.middleware.should be_empty
+      expect(app_const.middleware).to be_empty
     end
   end
 
@@ -229,20 +229,20 @@ describe Sinatra::Reloader do
     end
 
     it "doesn't mess up the application" do
-      get('/secret').should be_client_error
-      get('/secret').body.strip.should == 'Access forbiden'
+      expect(get('/secret')).to be_client_error
+      expect(get('/secret').body.strip).to eq('Access forbiden')
     end
 
     it "knows when a error has been added" do
       update_app_file(:errors => { 404 => "'Nowhere'" })
-      get('/nowhere').should be_not_found
-      get('/nowhere').body.should == 'Nowhere'
+      expect(get('/nowhere')).to be_not_found
+      expect(get('/nowhere').body).to eq('Nowhere')
     end
 
     it "knows when a error has been removed" do
       update_app_file(:routes => ['get("/secret") { 403 }'])
-      get('/secret').should be_client_error
-      get('/secret').body.should_not == 'Access forbiden'
+      expect(get('/secret')).to be_client_error
+      expect(get('/secret').body).not_to eq('Access forbiden')
     end
 
     it "knows when a error has been modified" do
@@ -250,8 +250,8 @@ describe Sinatra::Reloader do
         :routes => ['get("/secret") { 403 }'],
         :errors => { 403 => "'What are you doing here?'" }
       )
-      get('/secret').should be_client_error
-      get('/secret').body.should == 'What are you doing here?'
+      expect(get('/secret')).to be_client_error
+      expect(get('/secret').body).to eq('What are you doing here?')
     end
   end
 
@@ -352,20 +352,20 @@ describe Sinatra::Reloader do
     it "allows to specify a file to stop from being reloaded" do
       app_const.dont_reload app_file_path
       update_app_file(:routes => ['get("/foo") { "bar" }'])
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
     end
 
     it "allows to specify a glob to stop matching files from being reloaded" do
       app_const.dont_reload '**/*.rb'
       update_app_file(:routes => ['get("/foo") { "bar" }'])
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
     end
 
     it "doesn't interfere with other application's reloading policy" do
       app_const.dont_reload '**/*.rb'
       setup_example_app(:routes => ['get("/foo") { "foo" }'])
       update_app_file(:routes => ['get("/foo") { "bar" }'])
-      get('/foo').body.strip.should == 'bar'
+      expect(get('/foo').body.strip).to eq('bar')
     end
   end
 
@@ -382,19 +382,19 @@ describe Sinatra::Reloader do
     end
 
     it "allows to specify a file to be reloaded" do
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
       update_file(@foo_path) do |f|
         f.write 'class Foo; def self.foo() "bar" end end'
       end
-      get('/foo').body.strip.should == 'bar'
+      expect(get('/foo').body.strip).to eq('bar')
     end
 
     it "allows to specify glob to reaload matching files" do
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
       update_file(@foo_path) do |f|
         f.write 'class Foo; def self.foo() "bar" end end'
       end
-      get('/foo').body.strip.should == 'bar'
+      expect(get('/foo').body.strip).to eq('bar')
     end
 
     it "doesn't try to reload a removed file" do
@@ -402,17 +402,42 @@ describe Sinatra::Reloader do
         f.write 'class Foo; def self.foo() "bar" end end'
       end
       FileUtils.rm @foo_path
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
     end
 
     it "doesn't interfere with other application's reloading policy" do
       app_const.also_reload '**/*.rb'
       setup_example_app(:routes => ['get("/foo") { Foo.foo }'])
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
       update_file(@foo_path) do |f|
         f.write 'class Foo; def self.foo() "bar" end end'
       end
-      get('/foo').body.strip.should == 'foo'
+      expect(get('/foo').body.strip).to eq('foo')
+    end
+  end
+
+  describe ".after_reload" do
+    before(:each) do
+      setup_example_app(:routes => ['get("/foo") { Foo.foo }'])
+      @foo_path = File.join(tmp_dir, 'foo.rb')
+      update_file(@foo_path) do |f|
+        f.write 'class Foo; def self.foo() "foo" end end'
+      end
+      $LOADED_FEATURES.delete @foo_path
+      require @foo_path
+      app_const.also_reload @foo_path
+    end
+
+    it "allows block execution after reloading files" do
+      app_const.after_reload do
+        $reloaded = true
+      end
+      expect($reloaded).to eq(nil)
+      expect(get('/foo').body.strip).to eq('foo')
+      update_file(@foo_path) do |f|
+        f.write 'class Foo; def self.foo() "bar" end end'
+      end
+      expect($reloaded).to eq(true)
     end
   end
 
@@ -434,7 +459,7 @@ describe Sinatra::Reloader do
       :parent => 'Parent'
     )
 
-    get('/foo').body.should == 'bar'
+    expect(get('/foo').body).to eq('bar')
   end
 
 end

data/spec/required_params_spec.rb

@@ -0,0 +1,68 @@
+require_relative 'spec_helper'
+
+describe Sinatra::RequiredParams do
+  context "#required_params" do
+    context "simple keys" do
+      before do
+        mock_app do
+          helpers Sinatra::RequiredParams
+          get('/') { required_params(:p1, :p2) }
+        end
+      end
+      it 'return 400 if required params do not exist' do
+        get('/')
+        expect(last_response.status).to eq(400)
+      end
+      it 'return 400 if required params do not exist partially' do
+        get('/', :p1 => 1)
+        expect(last_response.status).to eq(400)
+      end
+      it 'return 200 if required params exist' do
+        get('/', :p1 => 1, :p2 => 2)
+        expect(last_response.status).to eq(200)
+      end
+      it 'return 200 if required params exist with array' do
+        get('/', :p1 => 1, :p2 => [31, 32, 33])
+        expect(last_response.status).to eq(200)
+      end
+    end
+    context "hash keys" do
+      before do
+        mock_app do
+          helpers Sinatra::RequiredParams
+          get('/') { required_params(:p1, :p2 => :p21) }
+        end
+      end
+      it 'return 400 if required params do not exist' do
+        get('/')
+        expect(last_response.status).to eq(400)
+      end
+      it 'return 200 if required params exist' do
+        get('/', :p1 => 1, :p2 => {:p21 => 21})
+        expect(last_response.status).to eq(200)
+      end
+    end
+    context "complex keys" do
+      before do
+        mock_app do
+          helpers Sinatra::RequiredParams
+          get('/') { required_params(:p1 => [:p11, {:p12 => :p121, :p122 => [:p123, {:p124 => :p1241}]}]) }
+        end
+      end
+      it 'return 400 if required params do not exist' do
+        get('/')
+        expect(last_response.status).to eq(400)
+      end
+      it 'return 200 if required params exist' do
+        get('/', :p1 => {:p11 => 11, :p12 => {:p121 => 121}, :p122 => {:p123 => 123, :p124 => {:p1241 => 1241}}})
+        expect(last_response.status).to eq(200)
+      end
+    end
+  end
+
+  context "#_required_params" do
+    it "is invisible" do
+      expect { _required_params }.to raise_error(NameError)
+    end
+  end
+end

data/spec/respond_with_spec.rb

@@ -40,8 +40,8 @@ describe Sinatra::RespondWith do
         format.json { "json!" }
       end
 
-      req(:html).body.should == "html!"
-      req(:json).body.should == "json!"
+      expect(req(:html).body).to eq("html!")
+      expect(req(:json).body).to eq("json!")
     end
 
     it 'respects quality' do
@@ -50,8 +50,8 @@ describe Sinatra::RespondWith do
         format.json { "json!" }
       end
 
-      req("text/html;q=0.7, application/json;q=0.3").body.should == "html!"
-      req("text/html;q=0.3, application/json;q=0.7").body.should == "json!"
+      expect(req("text/html;q=0.7, application/json;q=0.3").body).to eq("html!")
+      expect(req("text/html;q=0.3, application/json;q=0.7").body).to eq("json!")
     end
 
     it 'allows using mime types' do
@@ -60,7 +60,7 @@ describe Sinatra::RespondWith do
         format.json { "json!" }
       end
 
-      req(:html).body.should == "html!"
+      expect(req(:html).body).to eq("html!")
     end
 
     it 'allows using wildcards in format matchers' do
@@ -69,7 +69,7 @@ describe Sinatra::RespondWith do
         format.json { "json!" }
       end
 
-      req(:html).body.should == "text!"
+      expect(req(:html).body).to eq("text!")
     end
 
     it 'allows using catch all wildcards in format matchers' do
@@ -78,7 +78,7 @@ describe Sinatra::RespondWith do
         format.json { "json!" }
       end
 
-      req(:html).body.should == "anything!"
+      expect(req(:html).body).to eq("anything!")
     end
 
     it 'prefers concret over generic' do
@@ -88,14 +88,15 @@ describe Sinatra::RespondWith do
         format.json { "json!" }
       end
 
-      req(:json).body.should == "json!"
-      req(:html).body.should == "text!"
+      expect(req(:json).body).to eq("json!")
+      expect(req(:html).body).to eq("text!")
     end
 
     it 'does not set up default handlers' do
       respond_to
-      req.should_not be_ok
-      status.should == 406
+      expect(req).not_to be_ok
+      expect(status).to eq(500)
+      expect(body).to eq("Unknown template engine")
     end
   end
 
@@ -107,8 +108,8 @@ describe Sinatra::RespondWith do
           format.json { "json!" }
         end
 
-        req(:html).body.should == "html!"
-        req(:json).body.should == "json!"
+        expect(req(:html).body).to eq("html!")
+        expect(req(:json).body).to eq("json!")
       end
 
       it 'respects quality' do
@@ -117,8 +118,8 @@ describe Sinatra::RespondWith do
           format.json { "json!" }
         end
 
-        req("text/html;q=0.7, application/json;q=0.3").body.should == "html!"
-        req("text/html;q=0.3, application/json;q=0.7").body.should == "json!"
+        expect(req("text/html;q=0.7, application/json;q=0.3").body).to eq("html!")
+        expect(req("text/html;q=0.3, application/json;q=0.7").body).to eq("json!")
       end
 
       it 'allows using mime types' do
@@ -127,7 +128,7 @@ describe Sinatra::RespondWith do
           format.json { "json!" }
         end
 
-        req(:html).body.should == "html!"
+        expect(req(:html).body).to eq("html!")
       end
 
       it 'allows using wildcards in format matchers' do
@@ -136,7 +137,7 @@ describe Sinatra::RespondWith do
           format.json { "json!" }
         end
 
-        req(:html).body.should == "text!"
+        expect(req(:html).body).to eq("text!")
       end
 
       it 'allows using catch all wildcards in format matchers' do
@@ -145,7 +146,7 @@ describe Sinatra::RespondWith do
           format.json { "json!" }
         end
 
-        req(:html).body.should == "anything!"
+        expect(req(:html).body).to eq("anything!")
       end
 
       it 'prefers concret over generic' do
@@ -155,15 +156,15 @@ describe Sinatra::RespondWith do
           format.json { "json!" }
         end
 
-        req(:json).body.should == "json!"
-        req(:html).body.should == "text!"
+        expect(req(:json).body).to eq("json!")
+        expect(req(:html).body).to eq("text!")
       end
     end
 
     describe "default behavior" do
       it 'converts objects to json out of the box' do
         respond_with 'a' => 'b'
-        OkJson.decode(req(:json).body).should == {'a' => 'b'}
+        expect(OkJson.decode(req(:json).body)).to eq({'a' => 'b'})
       end
 
       it 'handles multiple routes correctly' do
@@ -171,68 +172,69 @@ describe Sinatra::RespondWith do
           get('/') { respond_with 'a' => 'b' }
           get('/:name') { respond_with 'a' => params[:name] }
         end
-        OkJson.decode(req('/',  :json).body).should == {'a' => 'b'}
-        OkJson.decode(req('/b', :json).body).should == {'a' => 'b'}
-        OkJson.decode(req('/c', :json).body).should == {'a' => 'c'}
+        expect(OkJson.decode(req('/',  :json).body)).to eq({'a' => 'b'})
+        expect(OkJson.decode(req('/b', :json).body)).to eq({'a' => 'b'})
+        expect(OkJson.decode(req('/c', :json).body)).to eq({'a' => 'c'})
       end
 
       it "calls to_EXT if available" do
         respond_with Struct.new(:to_pdf).new("hello")
-        req(:pdf).body.should == "hello"
+        expect(req(:pdf).body).to eq("hello")
       end
 
-      it 'results in a 406 if format cannot be produced' do
+      it 'results in a 500 if format cannot be produced' do
         respond_with({})
-        req(:html).should_not be_ok
-        status.should == 406
+        expect(req(:html)).not_to be_ok
+        expect(status).to eq(500)
+        expect(body).to eq("Unknown template engine")
       end
     end
 
     describe 'templates' do
       it 'looks for templates with name.target.engine' do
         respond_with :foo, :name => 'World'
-        req(:html).should be_ok
-        body.should == "Hello World!"
+        expect(req(:html)).to be_ok
+        expect(body).to eq("Hello World!")
       end
 
       it 'looks for templates with name.engine for specific engines' do
         respond_with :bar
-        req(:html).should be_ok
-        body.should == "guten Tag!"
+        expect(req(:html)).to be_ok
+        expect(body).to eq("guten Tag!")
       end
 
       it 'does not use name.engine for engines producing other formats' do
         respond_with :not_html
-        req(:html).should_not be_ok
-        status.should == 406
-        body.should be_empty
+        expect(req(:html)).not_to be_ok
+        expect(status).to eq(500)
+        expect(body).to eq("Unknown template engine")
       end
 
       it 'falls back to #json if no template is found' do
         respond_with :foo, :name => 'World'
-        req(:json).should be_ok
-        OkJson.decode(body).should == {'name' => 'World'}
+        expect(req(:json)).to be_ok
+        expect(OkJson.decode(body)).to eq({'name' => 'World'})
       end
 
       it 'favors templates over #json' do
         respond_with :bar, :name => 'World'
-        req(:json).should be_ok
-        body.should == 'json!'
+        expect(req(:json)).to be_ok
+        expect(body).to eq('json!')
       end
 
       it 'falls back to to_EXT if no template is found' do
         object = {:name => 'World'}
         def object.to_pdf; "hi" end
         respond_with :foo, object
-        req(:pdf).should be_ok
-        body.should == "hi"
+        expect(req(:pdf)).to be_ok
+        expect(body).to eq("hi")
       end
 
       unless defined? JRUBY_VERSION
         it 'uses yajl for json' do
           respond_with :baz
-          req(:json).should be_ok
-          body.should == "\"yajl!\""
+          expect(req(:json)).to be_ok
+          expect(body).to eq("\"yajl!\"")
         end
       end
     end
@@ -240,20 +242,20 @@ describe Sinatra::RespondWith do
     describe 'customizing' do
       it 'allows customizing' do
         respond_with(:foo, :name => 'World') { |f| f.html { 'html!' }}
-        req(:html).should be_ok
-        body.should == "html!"
+        expect(req(:html)).to be_ok
+        expect(body).to eq("html!")
       end
 
       it 'falls back to default behavior if none matches' do
         respond_with(:foo, :name => 'World') { |f| f.json { 'json!' }}
-        req(:html).should be_ok
-        body.should == "Hello World!"
+        expect(req(:html)).to be_ok
+        expect(body).to eq("Hello World!")
       end
 
       it 'favors generic rule over default behavior' do
         respond_with(:foo, :name => 'World') { |f| f.on('*/*') { 'generic!' }}
-        req(:html).should be_ok
-        body.should == "generic!"
+        expect(req(:html)).to be_ok
+        expect(body).to eq("generic!")
       end
     end
 
@@ -270,7 +272,7 @@ describe Sinatra::RespondWith do
         end
 
         self.app = Sinatra.new(app)
-        req('/a', :json).should_not be_ok
+        expect(req('/a', :json)).not_to be_ok
       end
     end
   end
@@ -283,8 +285,8 @@ describe Sinatra::RespondWith do
         get('/b') { 'ok' }
       end
 
-      req('/b', :xml).should_not be_ok
-      req('/b', :html).should be_ok
+      expect(req('/b', :xml)).not_to be_ok
+      expect(req('/b', :html)).to be_ok
     end
 
     it 'still allows provides' do
@@ -294,8 +296,8 @@ describe Sinatra::RespondWith do
         get('/b', :provides => :json) { 'ok' }
       end
 
-      req('/b', :html).should_not be_ok
-      req('/b', :json).should be_ok
+      expect(req('/b', :html)).not_to be_ok
+      expect(req('/b', :json)).to be_ok
     end
 
     it 'plays well with namespaces' do
@@ -308,8 +310,8 @@ describe Sinatra::RespondWith do
         get('/b') { 'anything' }
       end
 
-      req('/a', :html).should_not be_ok
-      req('/b', :html).should be_ok
+      expect(req('/a', :html)).not_to be_ok
+      expect(req('/b', :html)).to be_ok
     end
   end
 end