restfulness 0.3.2 → 0.3.3

data/spec/unit/request_spec.rb

@@ -23,50 +23,55 @@ describe Restfulness::Request do
   let :resource do
     RequestResource
   end
+
+  # Fake IO class, meant to mimic Puma::NullIO
+  class EmptyIO
+    def read(count = nil, buffer = nil); ""; end
+  end
     
   
   describe "#initialize" do
     it "should prepare basic objects" do
-      obj.action.should be_nil
-      obj.headers.should eql({})
-      obj.body.should be_nil
+      expect(obj.action).to be_nil
+      expect(obj.headers).to eql({})
+      expect(obj.body).to be_nil
     end
   end
 
   describe "#uri=" do
     it "should convert URL into URI" do
       obj.uri = "https://example.com/project/12345"
-      obj.uri.path.should eql("/project/12345")
+      expect(obj.uri.path).to eql("/project/12345")
     end
   end
 
   describe "#action" do
     it "should provide basic action" do
       obj.action = :get
-      obj.action.should eql(:get)
+      expect(obj.action).to eql(:get)
     end
   end
 
   describe "#path" do
     it "should be nil if there is no route" do
-      obj.stub(:route).and_return(nil)
-      obj.path.should be_nil
+      allow(obj).to receive(:route).and_return(nil)
+      expect(obj.path).to be_nil
     end
 
     context "with route" do
       let :path do
         obj.uri = "https://example.com/project/12345"
         route = Restfulness::Route.new('project', resource)
-        obj.stub(:route).and_return(route)
+        allow(obj).to receive(:route).and_return(route)
         obj.path
       end
 
       it "should build path" do
-        path.to_s.should eql('/project/12345')
+        expect(path.to_s).to eql('/project/12345')
       end
 
       it "should re-use same path object" do
-        path.object_id.should eql(obj.path.object_id)
+        expect(path.object_id).to eql(obj.path.object_id)
       end
     end
   end
@@ -75,57 +80,88 @@ describe Restfulness::Request do
     it "should ask the router for a route" do
       obj.uri = "https://example.com/project/12345"
       route = double(:Route)
-      app.router.should_receive(:route_for).with(obj.uri.path).and_return(route)
-      obj.route.should eql(route)
+      expect(app.router).to receive(:route_for).with(obj.uri.path).and_return(route)
+      expect(obj.route).to eql(route)
     end
   end
 
   describe "#query" do
     it "should parse uri with query" do
       obj.uri = "https://example.com/project/12345?foo=bar&test=23"
-      obj.query.should be_a(HashWithIndifferentAccess)
-      obj.query[:foo].should eql('bar')
-      obj.query[:test].to_i.should eql(23)
+      expect(obj.query).to be_a(HashWithIndifferentAccess)
+      expect(obj.query[:foo]).to eql('bar')
+      expect(obj.query[:test].to_i).to eql(23)
     end
 
     it "should handle uri with empty query" do
       obj.uri = "https://example.com/project/12345"
-      obj.query.should be_empty
+      expect(obj.query).to be_empty
     end
 
     it "should handle complex query items" do
       obj.uri = "https://example.com/project/12345?foo[]=bar&foo[]=bar2&hash[a]=b&hash[b]=c"
-      obj.query[:foo].should eql(['bar', 'bar2'])
-      obj.query[:hash].should be_a(HashWithIndifferentAccess)
-      obj.query[:hash][:a].should eql('b')
+      expect(obj.query[:foo]).to eql(['bar', 'bar2'])
+      expect(obj.query[:hash]).to be_a(HashWithIndifferentAccess)
+      expect(obj.query[:hash][:a]).to eql('b')
     end
   end
 
   describe "#sanitized_query_string" do
     it "should be empty if no query" do
       obj.uri = "https://example.com/project/12345"
-      obj.sanitized_query_string.should be_empty
+      expect(obj.sanitized_query_string).to be_empty
     end
     it "should filter out bad keys" do # See sanitizer tests for more
       obj.uri = "https://example.com/project/12345?foo=bar&password=safe"
-      obj.sanitized_query_string.should match(/foo=bar/)
-      obj.sanitized_query_string.should_not match(/password=safe/)
+      expect(obj.sanitized_query_string).to match(/foo=bar/)
+      expect(obj.sanitized_query_string).not_to match(/password=safe/)
+    end
+  end
+
+  describe "#content_type" do
+    it "should be nil if no content type" do
+      expect(obj.content_type).to be_nil
+    end
+
+    it "should provide a content type object for the request" do
+      obj.headers[:content_type] = "application/json; charset=utf-8"
+      expect(obj.content_type).to be_a(Restfulness::Headers::MediaType)
+      expect(obj.content_type.json?).to be true
+    end
+
+    it "should cache content_type object" do
+      obj.headers[:content_type] = "application/json"
+      obj.content_type.freeze
+      expect(obj.content_type.frozen?).to be true
+    end
+  end
+
+  describe "#accept" do
+    it "should be nil if no accept header provided" do
+      expect(obj.accept).to be_nil
+    end
+    it "should provide a accept object for the request" do
+      obj.headers[:accept] = "application/json; version=3"
+      expect(obj.accept).to be_a(Restfulness::Headers::Accept)
+      expect(obj.accept.json?).to be true
+      expect(obj.accept.version).to eql("3")
     end
   end
 
   describe "#params" do
     it "should not return anything for empty body" do
-      obj.stub(:body).and_return(nil)
-      obj.params.should be_empty
+      allow(obj).to receive(:body).and_return(nil)
+      expect(obj.params).to be_empty
     end
 
     it "should raise 400 bad request for invalid json body" do
       obj.headers[:content_type] = "application/json; charset=utf-8"
-      obj.stub(:body).and_return("invalidjson!")
+      allow(obj).to receive(:body).and_return('{"data":"invalid}')
       expect {
         obj.params
       }.to raise_error(Restfulness::HTTPException, "Bad Request"){ |exception|
         expect(exception.status).to eq 400
+        expect(exception.payload).to eq "Invalid JSON in request body"
       }
     end
 
@@ -150,78 +186,94 @@ describe Restfulness::Request do
     it "should decode a JSON body" do
       obj.headers[:content_type] = "application/json"
       obj.body = "{\"foo\":\"bar\"}"
-      obj.params['foo'].should eql('bar')
+      expect(obj.params['foo']).to eql('bar')
     end
 
     it "should decode a WWW Form body" do
       obj.headers[:content_type] = "application/x-www-form-urlencoded"
       obj.body = "grant_type=password&username=johndoe&password=A3ddj3w"
-      obj.params['grant_type'].should eql('password')
-      obj.params['username'].should eql('johndoe')
+      expect(obj.params['grant_type']).to eql('password')
+      expect(obj.params['username']).to eql('johndoe')
     end
 
     it "should deal with empty WWW Form body" do
       obj.headers[:content_type] = "application/x-www-form-urlencoded"
       obj.body = ""
-      obj.params.should be_empty
+      expect(obj.params).to be_empty
     end
 
     it "should deal with a StringIO WWW form body" do
       obj.headers[:content_type] = "application/x-www-form-urlencoded"
       obj.body = StringIO.new("grant_type=password&username=johndoe&password=A3ddj3w")
-      obj.params['grant_type'].should eql('password')
-      obj.params['username'].should eql('johndoe')
+      expect(obj.params['grant_type']).to eql('password')
+      expect(obj.params['username']).to eql('johndoe')
+    end
+
+    it "should deal with a Tempfile WWW form body" do
+      obj.headers[:content_type] = "application/x-www-form-urlencoded"
+      file = Tempfile.new("params")
+      file.write("grant_type=password&username=johndoe&password=A3ddj3w")
+      file.rewind
+      obj.body = file
+      expect(obj.params['grant_type']).to eql('password')
+      expect(obj.params['username']).to eql('johndoe')
     end
 
     it "should deal with empty JSON String body" do
       obj.headers[:content_type] = "application/json"
       obj.body = ""
-      obj.params.should be_empty
+      expect(obj.params).to be_empty
     end
 
     it "should deal with empty JSON StringIO body" do
       obj.headers[:content_type] = "application/json"
       obj.body = StringIO.new("")
-      obj.params.should be_empty
+      expect(obj.params).to be_empty
+    end
+
+    it "should handle some crappy IO object" do
+      obj.body = EmptyIO.new()
+      expect(obj.body).to receive(:read)
+      expect(obj.params).to be_empty
     end
   end
 
   describe "#sanitized_params" do
     it "should provide nil if the params hash has not been used" do
-      obj.stub(:body).and_return(nil)
-      obj.sanitized_params.should be_nil
+      allow(obj).to receive(:body).and_return(nil)
+      expect(obj.sanitized_params).to be_nil
     end
     it "should provide santized params if params have been used" do
       obj.headers[:content_type] = "application/json"
       obj.body = "{\"foo\":\"bar\",\"password\":\"safe\"}"
-      obj.params['password'].should eql('safe')
-      obj.sanitized_params['foo'].should eql('bar')
-      obj.sanitized_params['password'].should_not be_blank
-      obj.sanitized_params['password'].should_not eql('safe')
+      expect(obj.params['password']).to eql('safe')
+      expect(obj.sanitized_params['foo']).to eql('bar')
+      expect(obj.sanitized_params['password']).not_to be_blank
+      expect(obj.sanitized_params['password']).not_to eql('safe')
     end
   end
 
   describe "#http_accept_language" do
     it "should provide an instance of Parser" do
-      obj.http_accept_language.should be_a(HttpAcceptLanguage::Parser)
+      expect(obj.http_accept_language).to be_a(HttpAcceptLanguage::Parser)
     end
     it "should use the accept_language header" do
       header = "en-us,en-gb;q=0.8,en"
       obj.headers[:accept_language] = header
-      obj.http_accept_language.header.should eql(header)
+      expect(obj.http_accept_language.header).to eql(header)
     end
   end
 
   describe "method helpers" do
     it "should respond to method questions" do
       [:get?, :post?, :put?, :delete?, :head?, :options?].each do |q|
-        obj.should respond_to(q)
+        expect(obj).to respond_to(q)
       end
     end
     it "should suggest type of method" do
       obj.action = :get
-      obj.get?.should be_true
-      obj.post?.should be_false
+      expect(obj.get?).to be true
+      expect(obj.post?).to be false
     end
   end
 

data/spec/unit/requests/authorization_header_spec.rb

@@ -10,26 +10,26 @@ describe Restfulness::Requests::AuthorizationHeader do
 
     it "should accept standard header" do
       obj = klass.new("Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
-      obj.schema.should eql("Basic")
-      obj.params.should eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+      expect(obj.schema).to eql("Basic")
+      expect(obj.params).to eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
     end
 
     it "should accept non-standard schema" do
       obj = klass.new("bAsic QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
-      obj.schema.should eql("Basic")
-      obj.params.should eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+      expect(obj.schema).to eql("Basic")
+      expect(obj.params).to eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
     end
 
     it "should ignore any whitespace" do
       obj = klass.new(" Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ== ")
-      obj.schema.should eql("Basic")
-      obj.params.should eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+      expect(obj.schema).to eql("Basic")
+      expect(obj.params).to eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
     end
 
     it "should append additional stuff" do
       obj = klass.new("Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ== foooo")
-      obj.schema.should eql("Basic")
-      obj.params.should eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ== foooo")
+      expect(obj.schema).to eql("Basic")
+      expect(obj.params).to eql("QWxhZGRpbjpvcGVuIHNlc2FtZQ== foooo")
     end
 
   end

data/spec/unit/requests/authorization_spec.rb

@@ -17,14 +17,14 @@ describe Restfulness::Requests::Authorization do
 
     it "should be nil if no authorization header resent" do
       auth = request.authorization
-      auth.should be_nil
+      expect(auth).to be_nil
     end
  
     it "should build new authorization header when present" do
       request.headers[:authorization] = "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
       auth = request.authorization
-      auth.should be_a(Restfulness::Requests::AuthorizationHeader)
-      auth.schema.should eql("Basic")
+      expect(auth).to be_a(Restfulness::Requests::AuthorizationHeader)
+      expect(auth.schema).to eql("Basic")
     end
 
  end

data/spec/unit/resource_spec.rb

@@ -37,8 +37,8 @@ describe Restfulness::Resource do
     end
     it "should assign request and response" do
       obj = resource.new(request, response)
-      obj.request.should eql(request)
-      obj.response.should eql(response)
+      expect(obj.request).to eql(request)
+      expect(obj.response).to eql(response)
     end
   end
 
@@ -49,10 +49,10 @@ describe Restfulness::Resource do
 
     it "should return list of supported methods" do
       obj = resource.new(request, response)
-      obj.options.should be_nil
+      expect(obj.options).to be_nil
       acts = response.headers['Allow'].split(/, /)
       ['GET', 'POST', 'OPTIONS'].each do |act|
-        acts.should include(act)
+        expect(acts).to include(act)
       end
     end
   end
@@ -64,8 +64,8 @@ describe Restfulness::Resource do
     it "should perform action" do
       request.action = :get
       obj = resource.new(request, response)
-      obj.should_receive(:get).and_return('res')
-      obj.call.should eql('res')
+      expect(obj).to receive(:get).and_return('res')
+      expect(obj.call).to eql('res')
     end
 
   end
@@ -78,13 +78,13 @@ describe Restfulness::Resource do
     it "should be true on valid method" do
       request.action = :get
       obj = resource.new(request, response)
-      obj.method_allowed?.should be_true
+      expect(obj.method_allowed?).to be true
     end
 
     it "should be false on invalid method" do
       request.action = :put
       obj = resource.new(request, response)
-      obj.method_allowed?.should be_false
+      expect(obj.method_allowed?).to be false
     end
   end
 
@@ -99,14 +99,14 @@ describe Restfulness::Resource do
     end
 
     it "should all be true for questions" do
-      obj.exists?.should be_true
-      obj.authorized?.should be_true
-      obj.allowed?.should be_true
+      expect(obj.exists?).to be true
+      expect(obj.authorized?).to be true
+      expect(obj.allowed?).to be true
     end
 
     it "should be nil for values" do
-      obj.last_modified.should be_nil
-      obj.etag.should be_nil
+      expect(obj.last_modified).to be_nil
+      expect(obj.etag).to be_nil
     end
   end
 
@@ -131,12 +131,12 @@ describe Restfulness::Resource do
     end
 
     it "should try to set the locale" do
-      obj.should_receive(:set_locale)
+      expect(obj).to receive(:set_locale)
       obj.check_callbacks
     end
 
     it "should raise error on invalid method" do
-      obj.stub(:method_allowed?).and_return(false)
+      allow(obj).to receive(:method_allowed?).and_return(false)
       expect {
         obj.check_callbacks
       }.to raise_error(Restfulness::HTTPException, "Method Not Allowed")
@@ -145,7 +145,7 @@ describe Restfulness::Resource do
     [:head, :get, :patch, :delete].each do |action|
       it "should raise error when not exists for #{action.to_s.upcase}" do
         request.action = action
-        obj.stub(:exists?).and_return(false)
+        allow(obj).to receive(:exists?).and_return(false)
         expect {
           obj.check_callbacks
         }.to raise_error(Restfulness::HTTPException, "Resource Not Found")
@@ -155,20 +155,20 @@ describe Restfulness::Resource do
     [:put, :post].each do |action|
       it "should not check exists? for #{action.to_s.upcase}" do
         obj.request.action = action
-        obj.should_not_receive(:exists?)
+        expect(obj).not_to receive(:exists?)
         obj.check_callbacks
       end
     end
 
     it "should raise error when not authorized" do
-      obj.stub(:authorized?).and_return(false)
+      allow(obj).to receive(:authorized?).and_return(false)
       expect {
         obj.check_callbacks
       }.to raise_error(Restfulness::HTTPException, "Unauthorized")
     end
 
     it "should raise error when not allowed" do
-      obj.stub(:allowed?).and_return(false)
+      allow(obj).to receive(:allowed?).and_return(false)
       expect {
         obj.check_callbacks
       }.to raise_error(Restfulness::HTTPException, "Forbidden")
@@ -176,7 +176,7 @@ describe Restfulness::Resource do
 
     describe "with etag" do
       it "should raise error when equal" do
-        obj.stub(:etag).and_return('sometag')
+        allow(obj).to receive(:etag).and_return('sometag')
         request.headers[:if_none_match] = 'sometag'
         expect {
           obj.check_callbacks
@@ -184,7 +184,7 @@ describe Restfulness::Resource do
       end
 
       it "should continue if not equal" do
-        obj.stub(:etag).and_return('sometag')
+        allow(obj).to receive(:etag).and_return('sometag')
         request.headers[:if_none_match] = 'someoldtag'
         expect {
           obj.check_callbacks
@@ -192,7 +192,7 @@ describe Restfulness::Resource do
       end
       
       it "should not be called unless action is :get or :head" do
-        obj.should_not_receive(:etag)
+        expect(obj).not_to receive(:etag)
         request.headers[:if_none_match] = 'sometag'
         [:post, :put, :delete].each do |action|
           request.action = action
@@ -204,7 +204,7 @@ describe Restfulness::Resource do
     describe "with if modified" do
       it "should raise error when equal" do
         time = Time.now
-        obj.stub(:last_modified).and_return(time)
+        allow(obj).to receive(:last_modified).and_return(time)
         request.headers[:if_modified_since] = time.to_s
         expect {
           obj.check_callbacks
@@ -213,7 +213,7 @@ describe Restfulness::Resource do
 
       it "should continue if not equal" do
         time = Time.now
-        obj.stub(:last_modified).and_return(time)
+        allow(obj).to receive(:last_modified).and_return(time)
         request.headers[:if_modified_since] = (time - 60).to_s
         expect {
           obj.check_callbacks
@@ -221,7 +221,7 @@ describe Restfulness::Resource do
       end
 
       it "should not be called unless action is :get or :head" do
-        obj.should_not_receive(:last_modified)
+        expect(obj).not_to receive(:last_modified)
         request.headers[:if_modified_since] = 'somedate'
         [:post, :put, :delete].each do |action|
           request.action = action
@@ -251,16 +251,16 @@ describe Restfulness::Resource do
     describe "#locale" do
       it "should return acceptable locale" do
         I18n.available_locales = ['es']
-        obj.send(:locale).should eql(:es)
+        expect(obj.send(:locale)).to eql(:es)
       end
     end
 
     describe "#set_locale" do
       it "should set the global locale value" do
         I18n.available_locales = ['en', 'es']
-        I18n.locale.should_not eql(:es)
+        expect(I18n.locale).not_to eql(:es)
         obj.send(:set_locale)
-        I18n.locale.should eql(:es)
+        expect(I18n.locale).to eql(:es)
       end
     end