sinatra-contrib 1.4.7 → 2.0.0.beta1

data/spec/extension_spec.rb

@@ -22,11 +22,11 @@ describe Sinatra::Extension do
 
   before { mock_app { register ExampleExtension }}
 
-  it('allows using set') { settings.foo.should == :bar }
-  it('implements configure') { settings.reload_stuff.should be false }
+  it('allows using set') { expect(settings.foo).to eq(:bar) }
+  it('implements configure') { expect(settings.reload_stuff).to be false }
 
   it 'allows defing routes' do
-    get('/').should be_ok
-    body.should == "from extension, yay"
+    expect(get('/')).to be_ok
+    expect(body).to eq("from extension, yay")
   end
 end

data/spec/json_spec.rb

@@ -9,7 +9,7 @@ shared_examples_for "a json encoder" do |lib, const|
       require lib if lib
       @encoder = eval(const)
     rescue LoadError
-      pending "unable to load #{lib}"
+      skip "unable to load #{lib}"
     end
   end
 
@@ -37,7 +37,7 @@ describe Sinatra::JSON do
   end
 
   def results_in(obj)
-    OkJson.decode(get('/').body).should == obj
+    expect(OkJson.decode(get('/').body)).to eq(obj)
   end
 
   it "encodes objects to json out of the box" do
@@ -47,36 +47,36 @@ describe Sinatra::JSON do
 
   it "sets the content type to 'application/json'" do
     mock_app { get('/') { json({}) } }
-    get('/')["Content-Type"].should include("application/json")
+    expect(get('/')["Content-Type"]).to include("application/json")
   end
 
   it "allows overriding content type with :content_type" do
     mock_app { get('/') { json({}, :content_type => "foo/bar") } }
-    get('/')["Content-Type"].should == "foo/bar"
+    expect(get('/')["Content-Type"]).to eq("foo/bar")
   end
 
   it "accepts shorthands for :content_type" do
     mock_app { get('/') { json({}, :content_type => :js) } }
-    get('/')["Content-Type"].should == "application/javascript;charset=utf-8"
+    expect(get('/')["Content-Type"]).to eq("application/javascript;charset=utf-8")
   end
 
   it 'calls generate on :encoder if available' do
     enc = Object.new
     def enc.generate(obj) obj.inspect end
     mock_app { get('/') { json(42, :encoder => enc) }}
-    get('/').body.should == '42'
+    expect(get('/').body).to eq('42')
   end
 
   it 'calls encode on :encoder if available' do
     enc = Object.new
     def enc.encode(obj) obj.inspect end
     mock_app { get('/') { json(42, :encoder => enc) }}
-    get('/').body.should == '42'
+    expect(get('/').body).to eq('42')
   end
 
   it 'sends :encoder as method call if it is a Symbol' do
     mock_app { get('/') { json(42, :encoder => :inspect) }}
-    get('/').body.should == '42'
+    expect(get('/').body).to eq('42')
   end
 
   it 'calls generate on settings.json_encoder if available' do
@@ -86,7 +86,7 @@ describe Sinatra::JSON do
       set :json_encoder, enc
       get('/') { json 42 }
     end
-    get('/').body.should == '42'
+    expect(get('/').body).to eq('42')
   end
 
   it 'calls encode on settings.json_encode if available' do
@@ -96,7 +96,7 @@ describe Sinatra::JSON do
       set :json_encoder, enc
       get('/') { json 42 }
     end
-    get('/').body.should == '42'
+    expect(get('/').body).to eq('42')
   end
 
   it 'sends settings.json_encode  as method call if it is a Symbol' do
@@ -104,7 +104,7 @@ describe Sinatra::JSON do
       set :json_encoder, :inspect
       get('/') { json 42 }
     end
-    get('/').body.should == '42'
+    expect(get('/').body).to eq('42')
   end
 
   describe('Yajl')    { it_should_behave_like "a json encoder", "yajl", "Yajl::Encoder" } unless defined? JRUBY_VERSION

data/spec/link_header_spec.rb

@@ -30,70 +30,70 @@ describe Sinatra::LinkHeader do
   describe :link do
     it "sets link headers" do
       get '/'
-      headers['Link'].lines.should include('<booyah>; rel="something"')
+      expect(headers['Link'].lines).to include('<booyah>; rel="something"')
     end
 
     it "returns link html tags" do
       get '/'
-      body.should == '<link href="booyah" rel="something" />'
+      expect(body).to eq('<link href="booyah" rel="something" />')
     end
 
     it "takes an options hash" do
       get '/'
       elements = ["<something>", "foo=\"bar\"", "rel=\"from-filter\""]
-      headers['Link'].lines.first.strip.split('; ').sort.should == elements
+      expect(headers['Link'].split(",\n").first.strip.split('; ').sort).to eq(elements)
     end
   end
 
   describe :stylesheet do
     it 'sets link headers' do
       get '/style'
-      headers['Link'].should match(%r{^</style\.css>;})
+      expect(headers['Link']).to match(%r{^</style\.css>;})
     end
 
     it 'sets type to text/css' do
       get '/style'
-      headers['Link'].should include('type="text/css"')
+      expect(headers['Link']).to include('type="text/css"')
     end
 
     it 'sets rel to stylesheet' do
       get '/style'
-      headers['Link'].should include('rel="stylesheet"')
+      expect(headers['Link']).to include('rel="stylesheet"')
     end
 
     it 'returns html tag' do
       get '/style'
-      body.should match(%r{^<link href="/style\.css"})
+      expect(body).to match(%r{^<link href="/style\.css"})
     end
   end
 
   describe :prefetch do
     it 'sets link headers' do
       get '/prefetch'
-      headers['Link'].should match(%r{^</foo>;})
+      expect(headers['Link']).to match(%r{^</foo>;})
     end
 
     it 'sets rel to prefetch' do
       get '/prefetch'
-      headers['Link'].should include('rel="prefetch"')
+      expect(headers['Link']).to include('rel="prefetch"')
     end
 
     it 'returns html tag' do
       get '/prefetch'
-      body.should == '<link href="/foo" rel="prefetch" />'
+      expect(body).to eq('<link href="/foo" rel="prefetch" />')
     end
   end
 
   describe :link_headers do
     it 'generates html for all link headers' do
       get '/link_headers'
-      body.should include('<link href="/foo" rel="prefetch" />')
-      body.should include('<link href="/style.css" ')
+      expect(body).to include('<link href="/foo" rel="prefetch" />')
+      expect(body).to include('<link href="/style.css" ')
     end
 
     it "respects Link headers not generated on its own" do
       get '/link_headers'
-      body.should include('<link href="foo" bar="baz" />')
+      expect(body).to include('<link href="foo" bar="baz" />')
     end
   end
 end

data/spec/multi_route_spec.rb

@@ -8,8 +8,8 @@ describe Sinatra::MultiRoute do
       get('/') { 'normal' }
     end
 
-    get('/').should be_ok
-    body.should be == 'normal'
+    expect(get('/')).to be_ok
+    expect(body).to eq('normal')
   end
 
   it 'supports multiple routes' do
@@ -18,10 +18,10 @@ describe Sinatra::MultiRoute do
       get('/foo', '/bar') { 'paths' }
     end
 
-    get('/foo').should be_ok
-    body.should be == 'paths'
-    get('/bar').should be_ok
-    body.should be == 'paths'
+    expect(get('/foo')).to be_ok
+    expect(body).to eq('paths')
+    expect(get('/bar')).to be_ok
+    expect(body).to eq('paths')
   end
 
   it 'triggers conditions' do
@@ -32,7 +32,7 @@ describe Sinatra::MultiRoute do
       get('/foo', '/bar', :some_condition => true) { 'paths' }
     end
 
-    count.should be == 4
+    expect(count).to eq(4)
   end
 
   it 'supports multiple verbs' do
@@ -41,10 +41,10 @@ describe Sinatra::MultiRoute do
       route('PUT', 'POST', '/') { 'verb' }
     end
 
-    post('/').should be_ok
-    body.should be == 'verb'
-    put('/').should be_ok
-    body.should be == 'verb'
+    expect(post('/')).to be_ok
+    expect(body).to eq('verb')
+    expect(put('/')).to be_ok
+    expect(body).to eq('verb')
   end
 
   it 'takes symbols as verbs' do
@@ -53,7 +53,7 @@ describe Sinatra::MultiRoute do
       route(:get, '/baz') { 'symbol as verb' }
     end
 
-    get('/baz').should be_ok
-    body.should be == 'symbol as verb'
+    expect(get('/baz')).to be_ok
+    expect(body).to eq('symbol as verb')
   end
 end

data/spec/namespace_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe Sinatra::Namespace do
-  verbs = [:get, :head, :post, :put, :delete, :options]
-  verbs << :patch if Sinatra::VERSION >= '1.3'
+  verbs = [:get, :head, :post, :put, :delete, :options, :patch]
 
   def mock_app(&block)
     super do
@@ -20,96 +19,147 @@ describe Sinatra::Namespace do
 
       it 'prefixes the path with the namespace' do
         namespace('/foo') { send(verb, '/bar') { 'baz' }}
-        send(verb, '/foo/bar').should be_ok
-        body.should == 'baz' unless verb == :head
-        send(verb, '/foo/baz').should_not be_ok
+        expect(send(verb, '/foo/bar')).to be_ok
+        expect(body).to eq('baz') unless verb == :head
+        expect(send(verb, '/foo/baz')).not_to be_ok
+      end
+
+      describe 'redirect_to' do
+        it 'redirect within namespace' do
+          namespace('/foo') { send(verb, '/bar') { redirect_to '/foo_bar' }}
+          expect(send(verb, '/foo/bar')).to be_redirect
+          expect(send(verb, '/foo/bar').location).to include("/foo/foo_bar")
+        end
       end
 
       context 'when namespace is a string' do
         it 'accepts routes with no path' do
           namespace('/foo') { send(verb) { 'bar' } }
-          send(verb, '/foo').should be_ok
-          body.should == 'bar' unless verb == :head
+          expect(send(verb, '/foo')).to be_ok
+          expect(body).to eq('bar') unless verb == :head
         end
 
         it 'accepts the path as a named parameter' do
           namespace('/foo') { send(verb, '/:bar') { params[:bar] }}
-          send(verb, '/foo/bar').should be_ok
-          body.should == 'bar' unless verb == :head
-          send(verb, '/foo/baz').should be_ok
-          body.should == 'baz' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('bar') unless verb == :head
+          expect(send(verb, '/foo/baz')).to be_ok
+          expect(body).to eq('baz') unless verb == :head
         end
 
         it 'accepts the path as a regular expression' do
           namespace('/foo') { send(verb, /\/\d\d/) { 'bar' }}
-          send(verb, '/foo/12').should be_ok
-          body.should eq 'bar' unless verb == :head
-          send(verb, '/foo/123').should_not be_ok
+          expect(send(verb, '/foo/12')).to be_ok
+          expect(body).to eq 'bar' unless verb == :head
+          expect(send(verb, '/foo/123')).not_to be_ok
         end
       end
 
       context 'when namespace is a named parameter' do
         it 'accepts routes with no path' do
           namespace('/:foo') { send(verb) { 'bar' } }
-          send(verb, '/foo').should be_ok
-          body.should == 'bar' unless verb == :head
+          expect(send(verb, '/foo')).to be_ok
+          expect(body).to eq('bar') unless verb == :head
         end
 
         it 'sets the parameter correctly' do
           namespace('/:foo') { send(verb, '/bar') { params[:foo] }}
-          send(verb, '/foo/bar').should be_ok
-          body.should == 'foo' unless verb == :head
-          send(verb, '/fox/bar').should be_ok
-          body.should == 'fox' unless verb == :head
-          send(verb, '/foo/baz').should_not be_ok
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('foo') unless verb == :head
+          expect(send(verb, '/fox/bar')).to be_ok
+          expect(body).to eq('fox') unless verb == :head
+          expect(send(verb, '/foo/baz')).not_to be_ok
         end
 
         it 'accepts the path as a named parameter' do
           namespace('/:foo') { send(verb, '/:bar') { params[:bar] }}
-          send(verb, '/foo/bar').should be_ok
-          body.should == 'bar' unless verb == :head
-          send(verb, '/foo/baz').should be_ok
-          body.should == 'baz' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('bar') unless verb == :head
+          expect(send(verb, '/foo/baz')).to be_ok
+          expect(body).to eq('baz') unless verb == :head
         end
 
         it 'accepts the path as regular expression' do
           namespace('/:foo') { send(verb, %r{/bar}) { params[:foo] }}
-          send(verb, '/foo/bar').should be_ok
-          body.should == 'foo' unless verb == :head
-          send(verb, '/fox/bar').should be_ok
-          body.should == 'fox' unless verb == :head
-          send(verb, '/foo/baz').should_not be_ok
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('foo') unless verb == :head
+          expect(send(verb, '/fox/bar')).to be_ok
+          expect(body).to eq('fox') unless verb == :head
+          expect(send(verb, '/foo/baz')).not_to be_ok
         end
       end
 
       context 'when namespace is a regular expression' do
         it 'accepts routes with no path' do
           namespace(%r{/foo}) { send(verb) { 'bar' } }
-          send(verb, '/foo').should be_ok
-          body.should == 'bar' unless verb == :head
+          expect(send(verb, '/foo')).to be_ok
+          expect(body).to eq('bar') unless verb == :head
         end
 
         it 'accepts the path as a named parameter' do
           namespace(%r{/foo}) { send(verb, '/:bar') { params[:bar] }}
-          send(verb, '/foo/bar').should be_ok
-          body.should == 'bar' unless verb == :head
-          send(verb, '/foo/baz').should be_ok
-          body.should == 'baz' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('bar') unless verb == :head
+          expect(send(verb, '/foo/baz')).to be_ok
+          expect(body).to eq('baz') unless verb == :head
         end
 
         it 'accepts the path as a regular expression' do
           namespace(/\/\d\d/) { send(verb, /\/\d\d/) { 'foo' }}
-          send(verb, '/23/12').should be_ok
-          body.should == 'foo' unless verb == :head
-          send(verb, '/123/12').should_not be_ok
+          expect(send(verb, '/23/12')).to be_ok
+          expect(body).to eq('foo') unless verb == :head
+          expect(send(verb, '/123/12')).not_to be_ok
+        end
+
+        describe "before/after filters" do
+          it 'trigger before filter' do
+            ran = false
+            namespace(/\/foo\/([^\/&?]+)\/bar\/([^\/&?]+)\//) { before { ran = true };}
+
+            send(verb, '/bar/')
+            expect(ran).to eq(false)
+
+            send(verb, '/foo/1/bar/1/')
+            expect(ran).to eq(true)
+          end
+
+          it 'trigger after filter' do
+            ran = false
+            namespace(/\/foo\/([^\/&?]+)\/bar\/([^\/&?]+)\//) { after { ran = true };}
+
+            send(verb, '/bar/')
+            expect(ran).to eq(false)
+
+            send(verb, '/foo/1/bar/1/')
+            expect(ran).to eq(true)
+          end
+        end
+
+        describe 'helpers' do
+          it 'are defined using the helpers method' do
+            namespace /\/foo\/([^\/&?]+)\/bar\/([^\/&?]+)\// do
+              helpers do
+                def foo
+                  'foo'
+                end
+              end
+
+              send verb, '' do
+                foo.to_s
+              end
+            end
+
+            expect(send(verb, '/foo/1/bar/1/')).to be_ok
+            expect(body).to eq('foo') unless verb == :head
+          end
         end
       end
 
       context 'when namespace is a splat' do
         it 'accepts the path as a splat' do
           namespace('/*') { send(verb, '/*') { params[:splat].join ' - ' }}
-          send(verb, '/foo/bar').should be_ok
-          body.should == 'foo - bar' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('foo - bar') unless verb == :head
         end
       end
 
@@ -118,14 +168,14 @@ describe Sinatra::Namespace do
           ran = false
           namespace('/foo') { before { ran = true }}
           send(verb, '/foo')
-          ran.should be true
+          expect(ran).to be true
         end
 
         specify 'are not triggered for a different namespace' do
           ran = false
           namespace('/foo') { before { ran = true }}
           send(verb, '/fox')
-          ran.should be false
+          expect(ran).to be false
         end
       end
 
@@ -134,14 +184,14 @@ describe Sinatra::Namespace do
           ran = false
           namespace('/foo') { after { ran = true }}
           send(verb, '/foo')
-          ran.should be true
+          expect(ran).to be true
         end
 
         specify 'are not triggered for a different namespace' do
           ran = false
           namespace('/foo') { after { ran = true }}
           send(verb, '/fox')
-          ran.should be false
+          expect(ran).to be false
         end
       end
 
@@ -153,20 +203,20 @@ describe Sinatra::Namespace do
               send(verb, '/') { 'no' }
             end
             send(verb, '/', {}, 'HTTP_HOST' => 'example.com')
-            last_response.should be_ok
-            body.should == 'yes' unless verb == :head
+            expect(last_response).to be_ok
+            expect(body).to eq('yes') unless verb == :head
             send(verb, '/', {}, 'HTTP_HOST' => 'example.org')
-            last_response.should be_ok
-            body.should == 'no' unless verb == :head
+            expect(last_response).to be_ok
+            expect(body).to eq('no') unless verb == :head
           end
 
           specify 'are accepted in the route definition' do
             namespace :host_name => 'example.com' do
               send(verb, '/foo', :provides => :txt) { 'ok' }
             end
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain').should be_ok
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/html').should_not be_ok
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org', 'HTTP_ACCEPT' => 'text/plain').should_not be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')).to be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/html')).not_to be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org', 'HTTP_ACCEPT' => 'text/plain')).not_to be_ok
           end
 
           specify 'are accepted in the before-filter' do
@@ -176,13 +226,13 @@ describe Sinatra::Namespace do
               send(verb, '/*') { 'ok' }
             end
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org', 'HTTP_ACCEPT' => 'text/plain')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/html')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/bar', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-            ran.should be true
+            expect(ran).to be true
           end
 
           specify 'are accepted in the after-filter' do
@@ -192,13 +242,13 @@ describe Sinatra::Namespace do
               send(verb, '/*') { 'ok' }
             end
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org', 'HTTP_ACCEPT' => 'text/plain')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/html')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/bar', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-            ran.should be true
+            expect(ran).to be true
           end
         end
 
@@ -207,8 +257,8 @@ describe Sinatra::Namespace do
             namespace '/foo', :host_name => 'example.com' do
               send(verb) { 'ok' }
             end
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com').should be_ok
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org').should_not be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com')).to be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org')).not_to be_ok
           end
 
           specify 'are accepted in the before-filter' do
@@ -217,11 +267,11 @@ describe Sinatra::Namespace do
               send(verb) { @yes || 'no' }
             end
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com')
-            last_response.should be_ok
-            body.should == 'yes' unless verb == :head
+            expect(last_response).to be_ok
+            expect(body).to eq('yes') unless verb == :head
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org')
-            last_response.should be_ok
-            body.should == 'no' unless verb == :head
+            expect(last_response).to be_ok
+            expect(body).to eq('no') unless verb == :head
           end
 
           specify 'are accepted in the after-filter' do
@@ -231,17 +281,17 @@ describe Sinatra::Namespace do
               send(verb) { 'ok' }
             end
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org')
-            ran.should be false
+            expect(ran).to be false
             send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com')
-            ran.should be true
+            expect(ran).to be true
           end
 
           specify 'are accepted in the route definition' do
             namespace '/foo' do
               send(verb, :host_name => 'example.com') { 'ok' }
             end
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com').should be_ok
-            send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org').should_not be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com')).to be_ok
+            expect(send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org')).not_to be_ok
           end
 
           context 'when the namespace has a condition' do
@@ -252,11 +302,11 @@ describe Sinatra::Namespace do
                 send(verb) { 'ok' }
               end
               send(verb, '/', {}, 'HTTP_HOST' => 'example.org', 'HTTP_ACCEPT' => 'text/plain')
-              ran.should be false
+              expect(ran).to be false
               send(verb, '/', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/html')
-              ran.should be false
+              expect(ran).to be false
               send(verb, '/', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-              ran.should be true
+              expect(ran).to be true
             end
 
             specify 'are accepted in the filters' do
@@ -266,13 +316,13 @@ describe Sinatra::Namespace do
                 send(verb, '/*') { 'ok' }
               end
               send(verb, '/foo', {}, 'HTTP_HOST' => 'example.org', 'HTTP_ACCEPT' => 'text/plain')
-              ran.should be false
+              expect(ran).to be false
               send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/html')
-              ran.should be false
+              expect(ran).to be false
               send(verb, '/far', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-              ran.should be false
+              expect(ran).to be false
               send(verb, '/foo', {}, 'HTTP_HOST' => 'example.com', 'HTTP_ACCEPT' => 'text/plain')
-              ran.should be true
+              expect(ran).to be true
             end
           end
         end
@@ -292,8 +342,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar').should be_ok
-          body.should == '42' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('42') unless verb == :head
         end
 
         it 'can be defined as normal methods' do
@@ -307,8 +357,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar').should be_ok
-          body.should == '42' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('42') unless verb == :head
         end
 
         it 'can be defined using module mixins' do
@@ -325,8 +375,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar').should be_ok
-          body.should == '42' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('42') unless verb == :head
         end
 
         specify 'are unavailable outside the namespace where they are defined' do
@@ -346,7 +396,7 @@ describe Sinatra::Namespace do
             end
           end
 
-          proc { send verb, '/' }.should raise_error(NameError)
+          expect { send verb, '/' }.to raise_error(NameError)
         end
 
         specify 'are unavailable outside the namespace that they are mixed into' do
@@ -369,7 +419,7 @@ describe Sinatra::Namespace do
             end
           end
 
-          proc { send verb, '/' }.should raise_error(NameError)
+          expect { send verb, '/' }.to raise_error(NameError)
         end
 
         specify 'are available to nested namespaces' do
@@ -387,8 +437,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar').should be_ok
-          body.should == '42' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('42') unless verb == :head
         end
 
         specify 'can call super from nested definitions' do
@@ -410,8 +460,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar').should be_ok
-          body.should == '23' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('23') unless verb == :head
         end
       end
 
@@ -423,8 +473,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar/baz').should be_ok
-          body.should == 'OKAY!!11!' unless verb == :head
+          expect(send(verb, '/foo/bar/baz')).to be_ok
+          expect(body).to eq('OKAY!!11!') unless verb == :head
         end
 
         it 'exposes helpers to nested namespaces' do
@@ -442,8 +492,8 @@ describe Sinatra::Namespace do
             end
           end
 
-          send(verb, '/foo/bar/baz').should be_ok
-          body.should == '42' unless verb == :head
+          expect(send(verb, '/foo/bar/baz')).to be_ok
+          expect(body).to eq('42') unless verb == :head
         end
 
         specify 'does not provide access to nested helper methods' do
@@ -463,13 +513,13 @@ describe Sinatra::Namespace do
             end
           end
 
-          proc { send verb, '/foo' }.should raise_error(NameError)
+          expect { send verb, '/foo' }.to raise_error(NameError)
         end
 
         it 'accepts a nested namespace as a named parameter' do
           namespace('/:a') { namespace('/:b') { send(verb) { params[:a] }}}
-          send(verb, '/foo/bar').should be_ok
-          body.should ==  'foo' unless verb == :head
+          expect(send(verb, '/foo/bar')).to be_ok
+          expect(body).to eq('foo') unless verb == :head
         end
       end
 
@@ -478,24 +528,24 @@ describe Sinatra::Namespace do
           namespace('/de') do
             not_found { 'nicht gefunden' }
           end
-          send(verb, '/foo').status.should eq 404
-          last_response.body.should_not    eq 'nicht gefunden' unless verb == :head
-          get('/en/foo').status.should     eq 404
-          last_response.body.should_not    eq 'nicht gefunden' unless verb == :head
-          get('/de/foo').status.should     eq 404
-          last_response.body.should        eq 'nicht gefunden' unless verb == :head
+          expect(send(verb, '/foo').status).to eq 404
+          expect(last_response.body).not_to    eq 'nicht gefunden' unless verb == :head
+          expect(get('/en/foo').status).to     eq 404
+          expect(last_response.body).not_to    eq 'nicht gefunden' unless verb == :head
+          expect(get('/de/foo').status).to     eq 404
+          expect(last_response.body).to        eq 'nicht gefunden' unless verb == :head
         end
 
         it 'can be customized for specific error codes' do
           namespace('/de') do
             error(404) { 'nicht gefunden' }
           end
-          send(verb, '/foo').status.should eq 404
-          last_response.body.should_not    eq 'nicht gefunden' unless verb == :head
-          get('/en/foo').status.should     eq 404
-          last_response.body.should_not    eq 'nicht gefunden' unless verb == :head
-          get('/de/foo').status.should     eq 404
-          last_response.body.should        eq 'nicht gefunden' unless verb == :head
+          expect(send(verb, '/foo').status).to eq 404
+          expect(last_response.body).not_to    eq 'nicht gefunden' unless verb == :head
+          expect(get('/en/foo').status).to     eq 404
+          expect(last_response.body).not_to    eq 'nicht gefunden' unless verb == :head
+          expect(get('/de/foo').status).to     eq 404
+          expect(last_response.body).to        eq 'nicht gefunden' unless verb == :head
         end
 
         it 'falls back to the handler defined in the base app' do
@@ -507,12 +557,12 @@ describe Sinatra::Namespace do
               error(404) { 'nicht gefunden' }
             end
           end
-          send(verb, '/foo').status.should eq 404
-          last_response.body.should        eq 'not found...' unless verb == :head
-          get('/en/foo').status.should     eq 404
-          last_response.body.should        eq 'not found...' unless verb == :head
-          get('/de/foo').status.should     eq 404
-          last_response.body.should        eq 'nicht gefunden' unless verb == :head
+          expect(send(verb, '/foo').status).to eq 404
+          expect(last_response.body).to        eq 'not found...' unless verb == :head
+          expect(get('/en/foo').status).to     eq 404
+          expect(last_response.body).to        eq 'not found...' unless verb == :head
+          expect(get('/de/foo').status).to     eq 404
+          expect(last_response.body).to        eq 'nicht gefunden' unless verb == :head
         end
 
         it 'can be customized for specific Exception classes' do
@@ -542,10 +592,10 @@ describe Sinatra::Namespace do
               end
             end
           end
-          get('/en/foo').status.should     eq 401
-          last_response.body.should        eq 'auth failed' unless verb == :head
-          get('/de/foo').status.should     eq 406
-          last_response.body.should        eq 'methode nicht erlaubt' unless verb == :head
+          expect(get('/en/foo').status).to     eq 401
+          expect(last_response.body).to        eq 'auth failed' unless verb == :head
+          expect(get('/de/foo').status).to     eq 406
+          expect(last_response.body).to        eq 'methode nicht erlaubt' unless verb == :head
         end
 
         it "allows custom error handlers when namespace is declared as /en/:id. Issue #119" do
@@ -563,7 +613,7 @@ describe Sinatra::Namespace do
             end
           }
 
-          get('/en/1').status.should == 201
+          expect(get('/en/1').status).to eq(201)
         end
       end
 
@@ -578,8 +628,8 @@ describe Sinatra::Namespace do
               end
             end
 
-            send(verb, '/').body.should eq 'hi'
-            send(verb, '/foo').body.should eq 'hi'
+            expect(send(verb, '/').body).to eq 'hi'
+            expect(send(verb, '/foo').body).to eq 'hi'
           end
 
           specify 'can be nested' do
@@ -592,8 +642,8 @@ describe Sinatra::Namespace do
               end
             end
 
-            send(verb, '/').body.should eq 'hi'
-            send(verb, '/foo').body.should eq 'ho'
+            expect(send(verb, '/').body).to eq 'hi'
+            expect(send(verb, '/foo').body).to eq 'ho'
           end
 
           specify 'can use a custom views directory' do
@@ -606,8 +656,8 @@ describe Sinatra::Namespace do
               end
             end
 
-            send(verb, '/').body.should eq "hi\n"
-            send(verb, '/foo').body.should eq "ho\n"
+            expect(send(verb, '/').body).to eq "hi\n"
+            expect(send(verb, '/foo').body).to eq "ho\n"
           end
 
           specify 'default to the base app\'s layout' do
@@ -621,8 +671,8 @@ describe Sinatra::Namespace do
               end
             end
 
-            send(verb, '/').body.should eq 'he said: hi'
-            send(verb, '/foo').body.should eq 'he said: ho'
+            expect(send(verb, '/').body).to eq 'he said: hi'
+            expect(send(verb, '/foo').body).to eq 'he said: ho'
           end
 
           specify 'can define nested layouts' do
@@ -636,8 +686,8 @@ describe Sinatra::Namespace do
               end
             end
 
-            send(verb, '/').body.should eq 'Hello World!'
-            send(verb, '/foo').body.should eq 'Hi World!'
+            expect(send(verb, '/').body).to eq 'Hello World!'
+            expect(send(verb, '/foo').body).to eq 'Hi World!'
           end
         end
       end
@@ -651,7 +701,7 @@ describe Sinatra::Namespace do
               value = foo
             end
           end
-          value.should eq 42
+          expect(value).to eq 42
         end
 
         specify 'can be registered within a namespace' do
@@ -664,8 +714,8 @@ describe Sinatra::Namespace do
             end
             b = views
           end
-          a.should eq 'CUSTOM!!!'
-          b.should_not eq 'CUSTOM!!!'
+          expect(a).to eq 'CUSTOM!!!'
+          expect(b).not_to eq 'CUSTOM!!!'
         end
 
         specify 'trigger the route_added hook' do
@@ -681,11 +731,11 @@ describe Sinatra::Namespace do
             end
             get('/bar') { }
           end
-          route[1].should eq '/foo'
+          expect(route[1]).to eq(Mustermann.new '/foo')
         end
 
         specify 'prevent app-global settings from being changed' do
-          proc { namespace('/') { set :foo, :bar }}.should raise_error
+          expect { namespace('/') { set :foo, :bar }}.to raise_error(ArgumentError)
         end
       end
     end
@@ -703,8 +753,8 @@ describe Sinatra::Namespace do
         end
       end
 
-      get('/foo/bar').status.should == 200
-      last_response.body.should == 'ok'
+      expect(get('/foo/bar').status).to eq(200)
+      expect(last_response.body).to eq('ok')
     end
 
     it 'uses some repro' do
@@ -719,8 +769,8 @@ describe Sinatra::Namespace do
         end
       end
 
-      get('/foo/bar').status.should == 200
-      last_response.body.should == '42'
+      expect(get('/foo/bar').status).to eq(200)
+      expect(last_response.body).to eq('42')
     end
 
     it 'allows checking setting existence with respond_to?' do
@@ -734,8 +784,8 @@ describe Sinatra::Namespace do
         end
       end
 
-      get('/foo/bar').status.should == 200
-      last_response.body.should == 'true'
+      expect(get('/foo/bar').status).to eq(200)
+      expect(last_response.body).to eq('true')
     end
   end
 end