roda 2.2.0 → 2.3.0

data/spec/plugin/sinatra_helpers_spec.rb

@@ -18,90 +18,90 @@ describe "sinatra_helpers plugin" do
 
   it 'status returns the response status code if not given an argument' do
     status_app(207){status}
-    body.should == "207"
+    body.must_equal "207"
   end
 
   it 'status sets the response status code if given an argument' do
     status_app 207
-    status.should == 207
+    status.must_equal 207
   end
 
   it 'not_found? is true only if status == 404' do
     status_app(404){not_found?}
-    body.should == 'true'
+    body.must_equal 'true'
     status_app(405){not_found?}
-    body.should == 'false'
+    body.must_equal 'false'
     status_app(403){not_found?}
-    body.should == 'false'
+    body.must_equal 'false'
   end
 
   it 'informational? is true only for 1xx status' do
     status_app(100 + rand(100)){informational?}
-    body.should == 'true'
+    body.must_equal 'true'
     status_app(200 + rand(400)){informational?}
-    body.should == 'false'
+    body.must_equal 'false'
   end
 
   it 'success? is true only for 2xx status' do
     status_app(200 + rand(100)){success?}
-    body.should == 'true'
+    body.must_equal 'true'
     status_app(100 + rand(100)){success?}
-    body.should == 'false'
+    body.must_equal 'false'
     status_app(300 + rand(300)){success?}
-    body.should == 'false'
+    body.must_equal 'false'
   end
 
   it 'redirect? is true only for 3xx status' do
     status_app(300 + rand(100)){redirect?}
-    body.should == 'true'
+    body.must_equal 'true'
     status_app(200 + rand(100)){redirect?}
-    body.should == 'false'
+    body.must_equal 'false'
     status_app(400 + rand(200)){redirect?}
-    body.should == 'false'
+    body.must_equal 'false'
   end
 
   it 'client_error? is true only for 4xx status' do
     status_app(400 + rand(100)){client_error?}
-    body.should == 'true'
+    body.must_equal 'true'
     status_app(200 + rand(200)){client_error?}
-    body.should == 'false'
+    body.must_equal 'false'
     status_app(500 + rand(100)){client_error?}
-    body.should == 'false'
+    body.must_equal 'false'
   end
 
   it 'server_error? is true only for 5xx status' do
     status_app(500 + rand(100)){server_error?}
-    body.should == 'true'
+    body.must_equal 'true'
     status_app(200 + rand(300)){server_error?}
-    body.should == 'false'
+    body.must_equal 'false'
   end
 
   describe 'body' do
     it 'takes a block for deferred body generation' do
       sin_app{body{'Hello World'}; nil}
-      body.should == 'Hello World'
-      header('Content-Length').should == '11'
+      body.must_equal 'Hello World'
+      header('Content-Length').must_equal '11'
     end
 
     it 'supports #join' do
       sin_app{body{'Hello World'}; nil}
-      req[2].join.should == 'Hello World'
+      req[2].join.must_equal 'Hello World'
     end
 
     it 'takes a String, Array, or other object responding to #each' do
       sin_app{body 'Hello World'; nil}
-      body.should == 'Hello World'
-      header('Content-Length').should == '11'
+      body.must_equal 'Hello World'
+      header('Content-Length').must_equal '11'
 
       sin_app{body ['Hello ', 'World']; nil}
-      body.should == 'Hello World'
-      header('Content-Length').should == '11'
+      body.must_equal 'Hello World'
+      header('Content-Length').must_equal '11'
 
       o = Object.new
       def o.each; yield 'Hello World' end
       sin_app{body o; nil}
-      body.should == 'Hello World'
-      header('Content-Length').should == '11'
+      body.must_equal 'Hello World'
+      header('Content-Length').must_equal '11'
     end
   end
 
@@ -112,53 +112,53 @@ describe "sinatra_helpers plugin" do
         fail 'redirect should halt'
       end
 
-      status.should == 302
-      body.should == ''
-      header('Location').should == '/foo'
+      status.must_equal 302
+      body.must_equal ''
+      header('Location').must_equal '/foo'
     end
 
     it 'adds script_name if given a path' do
       sin_app{redirect "/foo"}
-      header('Location', '/bar', 'SCRIPT_NAME'=>'/foo').should == '/foo'
+      header('Location', '/bar', 'SCRIPT_NAME'=>'/foo').must_equal '/foo'
     end
 
     it 'does not adds script_name if not given a path' do
       sin_app{redirect}
-      header('Location', '/bar', 'SCRIPT_NAME'=>'/foo', 'REQUEST_METHOD'=>'POST').should == '/foo/bar'
+      header('Location', '/bar', 'SCRIPT_NAME'=>'/foo', 'REQUEST_METHOD'=>'POST').must_equal '/foo/bar'
     end
 
     it 'respects :absolute_redirects option' do
       sin_app{redirect}
       app.opts[:absolute_redirects] = true
-      header('Location', '/bar', 'HTTP_HOST'=>'example.org', 'SCRIPT_NAME'=>'/foo', 'REQUEST_METHOD'=>'POST').should == 'http://example.org/foo/bar'
+      header('Location', '/bar', 'HTTP_HOST'=>'example.org', 'SCRIPT_NAME'=>'/foo', 'REQUEST_METHOD'=>'POST').must_equal 'http://example.org/foo/bar'
     end
 
     it 'respects :prefixed_redirects option' do
       sin_app{redirect "/bar"}
       app.opts[:prefixed_redirects] = true
-      header('Location', 'SCRIPT_NAME'=>'/foo').should == '/foo/bar'
+      header('Location', 'SCRIPT_NAME'=>'/foo').must_equal '/foo/bar'
     end
 
     it 'ignores :prefix_redirects option if not given a path' do
       sin_app{redirect}
       app.opts[:prefix_redirects] = true
-      header('Location', "/bar", 'SCRIPT_NAME'=>'/foo', 'REQUEST_METHOD'=>'POST').should == '/foo/bar'
+      header('Location', "/bar", 'SCRIPT_NAME'=>'/foo', 'REQUEST_METHOD'=>'POST').must_equal '/foo/bar'
     end
 
     it 'uses the code given when specified' do
       sin_app{redirect '/foo', 301}
-      status.should == 301
+      status.must_equal 301
     end
 
     it 'redirects back to request.referer when passed back' do
       sin_app{redirect back}
-      header('Location', 'HTTP_REFERER' => '/foo').should == '/foo'
+      header('Location', 'HTTP_REFERER' => '/foo').must_equal '/foo'
     end
 
     it 'uses 303 for post requests if request is HTTP 1.1, 302 for 1.0' do
       sin_app{redirect '/foo'}
-      status('HTTP_VERSION' => 'HTTP/1.1', 'REQUEST_METHOD'=>'POST').should == 303
-      status('HTTP_VERSION' => 'HTTP/1.0', 'REQUEST_METHOD'=>'POST').should == 302
+      status('HTTP_VERSION' => 'HTTP/1.1', 'REQUEST_METHOD'=>'POST').must_equal 303
+      status('HTTP_VERSION' => 'HTTP/1.0', 'REQUEST_METHOD'=>'POST').must_equal 302
     end
   end
 
@@ -169,26 +169,26 @@ describe "sinatra_helpers plugin" do
         fail 'error should halt'
       end
 
-      status.should == 500
-      body.should == ''
+      status.must_equal 500
+      body.must_equal ''
     end
 
     it 'accepts status code' do
       sin_app{error 501}
-      status.should == 501
-      body.should == ''
+      status.must_equal 501
+      body.must_equal ''
     end
 
     it 'accepts body' do
       sin_app{error '501'}
-      status.should == 500
-      body.should == '501'
+      status.must_equal 500
+      body.must_equal '501'
     end
 
     it 'accepts status code and body' do
       sin_app{error 502, '501'}
-      status.should == 502
-      body.should == '501'
+      status.must_equal 502
+      body.must_equal '501'
     end
   end
 
@@ -199,14 +199,14 @@ describe "sinatra_helpers plugin" do
         fail 'not_found should halt'
       end
 
-      status.should == 404
-      body.should == ''
+      status.must_equal 404
+      body.must_equal ''
     end
 
     it 'accepts optional body' do
       sin_app{not_found 'nf'}
-      status.should == 404
-      body.should == 'nf'
+      status.must_equal 404
+      body.must_equal 'nf'
     end
   end
 
@@ -217,13 +217,13 @@ describe "sinatra_helpers plugin" do
         'kthx'
       end
 
-      header('X-Foo').should == 'bar'
-      body.should == 'kthx'
+      header('X-Foo').must_equal 'bar'
+      body.must_equal 'kthx'
     end
 
     it 'returns the response headers hash when no hash provided' do
       sin_app{headers['X-Foo'] = 'bar'}
-      header('X-Foo').should == 'bar'
+      header('X-Foo').must_equal 'bar'
     end
   end
 
@@ -234,26 +234,26 @@ describe "sinatra_helpers plugin" do
 
     it "looks up mime types in Rack's MIME registry" do
       Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
-      body('foo').should == 'application/foo'
-      body(:foo).should == 'application/foo'
-      body('.foo').should == 'application/foo'
+      body('foo').must_equal 'application/foo'
+      body(:foo).must_equal 'application/foo'
+      body('.foo').must_equal 'application/foo'
     end
 
     it 'returns nil when given nil' do
-      body('PATH_INFO'=>nil).should == ''
+      body('PATH_INFO'=>nil).must_equal ''
     end
 
     it 'returns nil when media type not registered' do
-      body('bizzle').should == ''
+      body('bizzle').must_equal ''
     end
 
     it 'returns the argument when given a media type string' do
-      body('text/plain').should == 'text/plain'
+      body('text/plain').must_equal 'text/plain'
     end
 
     it 'supports mime types registered at the class level' do
       app.mime_type :foo, 'application/foo'
-      body(:foo).should == 'application/foo'
+      body(:foo).must_equal 'application/foo'
     end
   end
 
@@ -264,41 +264,41 @@ describe "sinatra_helpers plugin" do
         'Hello World'
       end
 
-      header('Content-Type').should == 'text/plain'
-      body.should == 'Hello World'
+      header('Content-Type').must_equal 'text/plain'
+      body.must_equal 'Hello World'
     end
 
     it 'takes media type parameters (like charset=)' do
       sin_app{content_type 'text/html', :charset => 'latin1'}
-      header('Content-Type').should == 'text/html;charset=latin1'
+      header('Content-Type').must_equal 'text/html;charset=latin1'
     end
 
     it "looks up symbols in Rack's mime types dictionary" do
       sin_app{content_type :foo}
       Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
-      header('Content-Type').should == 'application/foo'
+      header('Content-Type').must_equal 'application/foo'
     end
 
     it 'fails when no mime type is registered for the argument provided' do
       sin_app{content_type :bizzle}
-      proc{body}.should raise_error(Roda::RodaError)
+      proc{body}.must_raise(Roda::RodaError)
     end
 
     it 'handles already present params' do
       sin_app{content_type 'foo/bar;level=1', :charset => 'utf-8'}
-      header('Content-Type').should == 'foo/bar;level=1, charset=utf-8'
+      header('Content-Type').must_equal 'foo/bar;level=1, charset=utf-8'
     end
 
     it 'does not add charset if present' do
       sin_app{content_type 'text/plain;charset=utf-16', :charset => 'utf-8'}
-      header('Content-Type').should == 'text/plain;charset=utf-16'
+      header('Content-Type').must_equal 'text/plain;charset=utf-16'
     end
 
     it 'properly encodes parameters with delimiter characters' do
       sin_app{|r| content_type 'image/png', :comment => r.path }
-      header('Content-Type', 'Hello, world!').should == 'image/png;comment="Hello, world!"'
-      header('Content-Type', 'semi;colon').should == 'image/png;comment="semi;colon"'
-      header('Content-Type', '"Whatever."').should == 'image/png;comment="\"Whatever.\""'
+      header('Content-Type', 'Hello, world!').must_equal 'image/png;comment="Hello, world!"'
+      header('Content-Type', 'semi;colon').must_equal 'image/png;comment="semi;colon"'
+      header('Content-Type', '"Whatever."').must_equal 'image/png;comment="\"Whatever.\""'
     end
   end
 
@@ -308,21 +308,21 @@ describe "sinatra_helpers plugin" do
     end
 
     it 'sets the Content-Disposition header' do
-      header('Content-Disposition', '/foo/test.xml').should == 'attachment; filename="test.xml"'
-      body.should == 'b'
+      header('Content-Disposition', '/foo/test.xml').must_equal 'attachment; filename="test.xml"'
+      body.must_equal 'b'
     end
 
     it 'sets the Content-Disposition header even when a filename is not given' do
       sin_app{attachment}
-      header('Content-Disposition', '/foo/test.xml').should == 'attachment'
+      header('Content-Disposition', '/foo/test.xml').must_equal 'attachment'
     end
 
     it 'sets the Content-Type header' do
-      header('Content-Type', 'test.xml').should == 'application/xml'
+      header('Content-Type', 'test.xml').must_equal 'application/xml'
     end
 
     it 'does not modify the default Content-Type without a file extension' do
-      header('Content-Type', 'README').should == 'text/html'
+      header('Content-Type', 'README').must_equal 'text/html'
     end
 
     it 'should not modify the Content-Type if it is already set' do
@@ -331,7 +331,7 @@ describe "sinatra_helpers plugin" do
         attachment 'test.xml'
       end
 
-      header('Content-Type', 'README').should == 'application/atom+xml'
+      header('Content-Type', 'README').must_equal 'application/atom+xml'
     end
   end
 
@@ -343,67 +343,67 @@ describe "sinatra_helpers plugin" do
     end
 
     it "sends the contents of the file" do
-      status.should == 200
-      body.should == @content
+      status.must_equal 200
+      body.must_equal @content
     end
 
     it 'sets the Content-Type response header if a mime-type can be located' do
-      header('Content-Type').should == 'text/css'
+      header('Content-Type').must_equal 'text/css'
     end
 
     it 'sets the Content-Type response header if type option is set to a file extension' do
-      header('Content-Type', 'OPTS'=>{:type => 'html'}).should == 'text/html'
+      header('Content-Type', 'OPTS'=>{:type => 'html'}).must_equal 'text/html'
     end
 
     it 'sets the Content-Type response header if type option is set to a mime type' do
-      header('Content-Type', 'OPTS'=>{:type => 'application/octet-stream'}).should == 'application/octet-stream'
+      header('Content-Type', 'OPTS'=>{:type => 'application/octet-stream'}).must_equal 'application/octet-stream'
     end
 
     it 'sets the Content-Length response header' do
-      header('Content-Length').should == @content.length.to_s
+      header('Content-Length').must_equal @content.length.to_s
     end
 
     it 'sets the Last-Modified response header' do
-      header('Last-Modified').should == File.mtime(@file).httpdate
+      header('Last-Modified').must_equal File.mtime(@file).httpdate
     end
 
     it 'allows passing in a different Last-Modified response header with :last_modified' do
       time = Time.now
       @app.plugin :caching
-      header('Last-Modified', 'OPTS'=>{:last_modified => time}).should == time.httpdate
+      header('Last-Modified', 'OPTS'=>{:last_modified => time}).must_equal time.httpdate
     end
 
     it "returns a 404 when not found" do
       sin_app{send_file 'this-file-does-not-exist.txt'}
-      status.should == 404
+      status.must_equal 404
     end
 
     it "does not set the Content-Disposition header by default" do
-      header('Content-Disposition').should == nil
+      header('Content-Disposition').must_equal nil
     end
 
     it "sets the Content-Disposition header when :disposition set to 'attachment'" do
-      header('Content-Disposition', 'OPTS'=>{:disposition => 'attachment'}).should == 'attachment; filename="raw.css"'
+      header('Content-Disposition', 'OPTS'=>{:disposition => 'attachment'}).must_equal 'attachment; filename="raw.css"'
     end
 
     it "does not set add a file name if filename is false" do
-      header('Content-Disposition', 'OPTS'=>{:disposition => 'inline', :filename=>false}).should == 'inline'
+      header('Content-Disposition', 'OPTS'=>{:disposition => 'inline', :filename=>false}).must_equal 'inline'
     end
 
     it "sets the Content-Disposition header when :disposition set to 'inline'" do
-      header('Content-Disposition', 'OPTS'=>{:disposition => 'inline'}).should == 'inline; filename="raw.css"'
+      header('Content-Disposition', 'OPTS'=>{:disposition => 'inline'}).must_equal 'inline; filename="raw.css"'
     end
 
     it "sets the Content-Disposition header when :filename provided" do
-      header('Content-Disposition', 'OPTS'=>{:filename => 'foo.txt'}).should == 'attachment; filename="foo.txt"'
+      header('Content-Disposition', 'OPTS'=>{:filename => 'foo.txt'}).must_equal 'attachment; filename="foo.txt"'
     end
 
     it 'allows setting a custom status code' do
-      status('OPTS'=>{:status=>201}).should == 201
+      status('OPTS'=>{:status=>201}).must_equal 201
     end
 
     it "is able to send files with unknown mime type" do
-      header('Content-Type', 'OPTS'=>{:type => '.foobar'}).should == 'application/octet-stream'
+      header('Content-Type', 'OPTS'=>{:type => '.foobar'}).must_equal 'application/octet-stream'
     end
 
     it "does not override Content-Type if already set and no explicit type is given" do
@@ -412,7 +412,7 @@ describe "sinatra_helpers plugin" do
         content_type :png
         send_file file
       end
-      header('Content-Type').should == 'image/png'
+      header('Content-Type').must_equal 'image/png'
     end
 
     it "does override Content-Type even if already set, if explicit type is given" do
@@ -421,7 +421,7 @@ describe "sinatra_helpers plugin" do
         content_type :png
         send_file file, :type => :gif
       end
-      header('Content-Type').should == 'image/gif'
+      header('Content-Type').must_equal 'image/gif'
     end
   end
 
@@ -432,78 +432,78 @@ describe "sinatra_helpers plugin" do
       end
 
       it 'generates absolute urls' do
-        body('HTTP_HOST'=>'example.org').should == 'http://example.org/'
+        body('HTTP_HOST'=>'example.org').must_equal 'http://example.org/'
       end
 
       it 'includes path_info' do
-        body('/foo', 'HTTP_HOST'=>'example.org').should == 'http://example.org/foo'
+        body('/foo', 'HTTP_HOST'=>'example.org').must_equal 'http://example.org/foo'
       end
 
       it 'includes script_name' do
-        body('/bar', 'HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/foo').should == 'http://example.org/foo/bar'
+        body('/bar', 'HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/foo').must_equal 'http://example.org/foo/bar'
       end
 
       it 'handles standard HTTP and HTTPS ports' do
-        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '80').should == 'http://example.org/'
-        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '443', 'HTTPS'=>'on').should == 'https://example.org/'
+        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '80').must_equal 'http://example.org/'
+        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '443', 'HTTPS'=>'on').must_equal 'https://example.org/'
       end
 
       it 'handles non-standard HTTP port' do
-        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '81').should == 'http://example.org:81/'
-        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '443').should == 'http://example.org:443/'
+        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '81').must_equal 'http://example.org:81/'
+        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '443').must_equal 'http://example.org:443/'
       end
 
       it 'handles non-standard HTTPS port' do
-        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '444', 'HTTPS'=>'on').should == 'https://example.org:444/'
-        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '80', 'HTTPS'=>'on').should == 'https://example.org:80/'
+        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '444', 'HTTPS'=>'on').must_equal 'https://example.org:444/'
+        body('SERVER_NAME'=>'example.org', 'SERVER_PORT' => '80', 'HTTPS'=>'on').must_equal 'https://example.org:80/'
       end
 
       it 'handles reverse proxy' do
-        body('SERVER_NAME'=>'example.org', 'HTTP_X_FORWARDED_HOST' => 'example.com', 'SERVER_PORT' => '8080').should == 'http://example.com/'
+        body('SERVER_NAME'=>'example.org', 'HTTP_X_FORWARDED_HOST' => 'example.com', 'SERVER_PORT' => '8080').must_equal 'http://example.com/'
       end
     end
 
     it 'allows passing an alternative to path_info' do
       sin_app{uri '/bar'}
-      body('HTTP_HOST'=>'example.org').should == 'http://example.org/bar'
-      body('HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/foo').should == 'http://example.org/foo/bar'
+      body('HTTP_HOST'=>'example.org').must_equal 'http://example.org/bar'
+      body('HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/foo').must_equal 'http://example.org/foo/bar'
     end
 
     it 'handles absolute URIs' do
       sin_app{uri 'http://google.com'}
-      body('HTTP_HOST'=>'example.org').should == 'http://google.com'
+      body('HTTP_HOST'=>'example.org').must_equal 'http://google.com'
     end
 
     it 'handles different protocols' do
       sin_app{uri 'mailto:jsmith@example.com'}
-      body('HTTP_HOST'=>'example.org').should == 'mailto:jsmith@example.com'
+      body('HTTP_HOST'=>'example.org').must_equal 'mailto:jsmith@example.com'
     end
 
     it 'allows turning off host' do
       sin_app{uri '/foo', false}
-      body('HTTP_HOST'=>'example.org').should == '/foo'
-      body('HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/bar').should == '/bar/foo'
+      body('HTTP_HOST'=>'example.org').must_equal '/foo'
+      body('HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/bar').must_equal '/bar/foo'
     end
 
     it 'allows turning off script_name' do
       sin_app{uri '/foo', true, false}
-      body('HTTP_HOST'=>'example.org').should == 'http://example.org/foo'
-      body('HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/bar').should == 'http://example.org/foo'
+      body('HTTP_HOST'=>'example.org').must_equal 'http://example.org/foo'
+      body('HTTP_HOST'=>'example.org', "SCRIPT_NAME" => '/bar').must_equal 'http://example.org/foo'
     end
 
     it 'is aliased to #url' do
       sin_app{url}
-      body('HTTP_HOST'=>'example.org').should == 'http://example.org/'
+      body('HTTP_HOST'=>'example.org').must_equal 'http://example.org/'
     end
 
     it 'is aliased to #to' do
       sin_app{to}
-      body('HTTP_HOST'=>'example.org').should == 'http://example.org/'
+      body('HTTP_HOST'=>'example.org').must_equal 'http://example.org/'
     end
 
     it 'accepts a URI object instead of a String' do
       sin_app{uri URI.parse('http://roda.jeremyevans.net')}
-      body.should == 'http://roda.jeremyevans.net'
+      body.must_equal 'http://roda.jeremyevans.net'
     end
   end
 
@@ -517,8 +517,8 @@ describe "sinatra_helpers plugin" do
       @a
     end
 
-    status('rack.logger'=>o).should == 404
-    o.logs.should == [[:info, 'foo']]
+    status('rack.logger'=>o).must_equal 404
+    o.logs.must_equal [[:info, 'foo']]
   end
 
   it 'supports disabling delegation if :delegate=>false option is provided' do
@@ -531,9 +531,9 @@ describe "sinatra_helpers plugin" do
       end
     end
 
-    proc{body}.should raise_error(NameError)
-    body('/req').should == 'false'
-    body('/res').should == 'nil'
+    proc{body}.must_raise(NameError)
+    body('/req').must_equal 'false'
+    body('/res').must_equal 'nil'
   end
 end