grape 0.1.5 → 0.2.0

data/spec/grape/middleware/auth/basic_spec.rb

@@ -20,12 +20,12 @@ describe Grape::Middleware::Auth::Basic do
   end
   
   it 'should authenticate if given valid creds' do
-    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic('admin','admin')
+    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin','admin')
     last_response.status.should == 200
   end
   
   it 'should throw a 401 is wrong auth is given' do
-    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic('admin','wrong')
+    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin','wrong')
     last_response.status.should == 401
   end
 end

data/spec/grape/middleware/auth/digest_spec.rb

@@ -9,8 +9,6 @@ RSpec::Matchers.define :be_challenge do
 end
 
 class Test < Grape::API
-  version '1'
-  
   http_digest({:realm => 'Test Api', :opaque => 'secret'}) do |username|
     {'foo' => 'bar'}[username]
   end
@@ -26,24 +24,24 @@ describe Grape::Middleware::Auth::Digest do
   end
   
   it 'should be a digest authentication challenge' do
-    get '/1/test'
+    get '/test'
     last_response.should be_challenge
   end
   
   it 'should throw a 401 if no auth is given' do
-    get '/1/test'
+    get '/test'
     last_response.status.should == 401
   end
 
   it 'should authenticate if given valid creds' do
     digest_authorize "foo", "bar"
-    get '/1/test'
+    get '/test'
     last_response.status.should == 200
   end
 
   it 'should throw a 401 if given invalid creds' do
     digest_authorize "bar", "foo"
-    get '/1/test'
+    get '/test'
     last_response.status.should == 401
   end
 end

data/spec/grape/middleware/exception_spec.rb

@@ -116,5 +116,6 @@ describe Grape::Middleware::Error do
       get '/'
       last_response.status.should == 401    
     end 
+    
   end 
 end

data/spec/grape/middleware/formatter_spec.rb

@@ -1,42 +1,65 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Formatter do
-  subject{ Grape::Middleware::Formatter.new(app, :default_format => :json)}
+  subject{ Grape::Middleware::Formatter.new(app) }
   before{ subject.stub!(:dup).and_return(subject) }
-  
+
   let(:app){ lambda{|env| [200, {}, [@body]]} }
-  
+
   context 'serialization' do
     it 'should look at the bodies for possibly serializable data' do
       @body = {"abc" => "def"}
-      status, headers, bodies = *subject.call({'PATH_INFO' => '/somewhere'})
+      status, headers, bodies = *subject.call({'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json'})
       bodies.each{|b| b.should == MultiJson.encode(@body) }
     end
-    
+
     it 'should call #to_json first if it is available' do
-      @body = "string"
+      @body = ['foo']
       @body.instance_eval do
         def to_json
           "\"bar\""
         end
       end
-      
-      subject.call({'PATH_INFO' => '/somewhere'}).last.each{|b| b.should == '"bar"'}
+
+      subject.call({'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json'}).last.each{|b| b.should == '"bar"'}
     end
-    
+
     it 'should serialize the #serializable_hash if that is available' do
       class SimpleExample
         def serializable_hash
           {:abc => 'def'}
         end
       end
-      
+
+      @body = [SimpleExample.new, SimpleExample.new]
+
+      subject.call({'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json'}).last.each{|b| b.should == '[{"abc":"def"},{"abc":"def"}]'}
+    end
+
+    it 'should serialize multiple objects that respond to #serializable_hash' do
+      class SimpleExample
+        def serializable_hash
+          {:abc => 'def'}
+        end
+      end
+
       @body = SimpleExample.new
-      
-      subject.call({'PATH_INFO' => '/somewhere'}).last.each{|b| b.should == '{"abc":"def"}'}
+
+      subject.call({'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json'}).last.each{|b| b.should == '{"abc":"def"}'}
+    end
+
+    it 'should call #to_xml if the content type is xml' do
+      @body = "string"
+      @body.instance_eval do
+        def to_xml
+          "<bar/>"
+        end
+      end
+
+      subject.call({'PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json'}).last.each{|b| b.should == '<bar/>'}
     end
   end
-  
+
   context 'detection' do
     it 'should use the extension if one is provided' do
       subject.call({'PATH_INFO' => '/info.xml'})
@@ -44,45 +67,60 @@ describe Grape::Middleware::Formatter do
       subject.call({'PATH_INFO' => '/info.json'})
       subject.env['api.format'].should == :json
     end
-    
+
     it 'should use the default format if none is provided' do
       subject.call({'PATH_INFO' => '/info'})
+      subject.env['api.format'].should == :txt
+    end
+
+    it 'should use the requested format if provided in headers' do
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json'})
       subject.env['api.format'].should == :json
     end
+
+    it 'should use the file extension format if provided before headers' do
+      subject.call({'PATH_INFO' => '/info.txt', 'HTTP_ACCEPT' => 'application/json'})
+      subject.env['api.format'].should == :txt
+    end
     
     it 'should throw an error on an unrecognized format' do
       err = catch(:error){ subject.call({'PATH_INFO' => '/info.barklar'}) }
       err.should == {:status => 406, :message => "The requested format is not supported."}
     end
   end
-  
+
   context 'Accept header detection' do
     it 'should detect from the Accept header' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/xml'})
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/xml'})
       subject.env['api.format'].should == :xml
     end
-    
+
     it 'should look for case-indifferent headers' do
-      subject.call({'PATH_INFO' => '/info', 'accept' => 'application/xml'})
+      subject.call({'PATH_INFO' => '/info', 'http_accept' => 'application/xml'})
       subject.env['api.format'].should == :xml
     end
-    
+
     it 'should use quality rankings to determine formats' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json; q=0.3,application/xml; q=1.0'})
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; q=0.3,application/xml; q=1.0'})
       subject.env['api.format'].should == :xml
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json; q=1.0,application/xml; q=0.3'})
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; q=1.0,application/xml; q=0.3'})
       subject.env['api.format'].should == :json
     end
-    
+
     it 'should handle quality rankings mixed with nothing' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json,application/xml; q=1.0'})
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json,application/xml; q=1.0'})
       subject.env['api.format'].should == :xml
     end
-    
+
     it 'should properly parse headers with other attributes' do
-      subject.call({'PATH_INFO' => '/info', 'Accept' => 'application/json; abc=2.3; q=1.0,application/xml; q=0.7'})
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; abc=2.3; q=1.0,application/xml; q=0.7'})
       subject.env['api.format'].should == :json
     end
+
+    it 'should properly parse headers with vendor and api version' do
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/vnd.test-v1+xml'})
+      subject.env['api.format'].should == :xml
+    end
   end
 
   context 'Content-type' do
@@ -113,9 +151,9 @@ describe Grape::Middleware::Formatter do
       body.body.should == ['CUSTOM FORMAT']
     end
     it 'should use default json formatter' do
-      @body = 'blah'
+      @body = ['blah']
       _, _, body = subject.call({'PATH_INFO' => '/info.json'})
-      body.body.should == ['"blah"']
+      body.body.should == ['["blah"]']
     end
     it 'should use custom json formatter' do
       subject.options[:formatters][:json] = lambda { |obj| 'CUSTOM JSON FORMAT' }
@@ -123,4 +161,20 @@ describe Grape::Middleware::Formatter do
       body.body.should == ['CUSTOM JSON FORMAT']
     end
   end
+
+  context 'Input' do
+    it 'should parse the body from a POST/PUT and put the contents into rack.request.form_hash' do
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json', 'rack.input' => StringIO.new('{"is_boolean":true,"string":"thing"}')})
+      subject.env['rack.request.form_hash']['is_boolean'].should be_true
+      subject.env['rack.request.form_hash']['string'].should == 'thing'
+    end
+    it 'should parse the body from an xml POST/PUT and put the contents into rack.request.from_hash' do
+      subject.call({'PATH_INFO' => '/info.xml', 'HTTP_ACCEPT' => 'application/xml', 'rack.input' => StringIO.new('<thing><name>Test</name></thing>')})
+      subject.env['rack.request.form_hash']['thing']['name'].should == 'Test'
+    end
+    it 'should be able to fail gracefully if the body is regular POST content' do
+      subject.call({'PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json', 'rack.input' => StringIO.new('name=Other+Test+Thing')})
+      subject.env['rack.request.form_hash'].should be_nil
+    end
+  end
 end

data/spec/grape/middleware/versioner/header_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Versioner::Header do
+  let(:app) { lambda{|env| [200, env, env]} }
+  let(:accept) { 'application/vnd.vendor-v1+json' }
+  subject { Grape::Middleware::Versioner::Header.new(app, @options || {}) }
+
+  context 'api.type and api.subtype' do
+    it 'should set any type and any subtype' do
+      env = subject.call('HTTP_ACCEPT' => '*/*').last
+      env['api.type'].should eql '*'
+      env['api.subtype'].should eql '*'
+    end
+
+    it 'should set preferred type and subtype' do
+      env = subject.call('HTTP_ACCEPT' => 'text/html').last
+      env['api.type'].should eql 'text'
+      env['api.subtype'].should eql 'html'
+    end
+  end
+
+  context 'api.format' do
+    it 'should be set' do
+      env = subject.call('HTTP_ACCEPT' => accept).last
+      env['api.format'].should eql 'json'
+    end
+
+    it 'should be nil if not provided' do
+      env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1').last
+      env['api.format'].should eql nil
+    end
+  end
+
+  context 'matched version' do
+    before do
+      @options = {
+        :versions => ['v1'],
+        :version_options => {:using => :header}
+      }
+    end
+
+    it 'should set api.vendor' do
+      env = subject.call('HTTP_ACCEPT' => accept).last
+      env['api.vendor'].should eql 'vendor'
+    end
+
+    it 'should set api.version' do
+      env = subject.call('HTTP_ACCEPT' => accept).last
+      env['api.version'].should eql 'v1'
+    end
+  end
+
+  context 'no header' do
+    it 'should return a 200 when no header is set and no strict setting is done' do
+      @options = {
+        :versions => ['v1'],
+        :version_options => {:using => :header}
+      }
+      subject.call('HTTP_ACCEPT' => '').first.should == 200
+      subject.call({}).first.should == 200
+    end
+
+    it 'should return a 200 when no header is set but strict header based versioning is disabled' do
+      @options = {
+        :versions => ['v1'],
+        :version_options => {:using => :header, :strict => false}
+      }
+      subject.call('HTTP_ACCEPT' => '').first.should == 200
+      subject.call({}).first.should == 200
+    end
+
+    context 'when strict header versioning is used' do
+      it 'should return a 406 when no header' do
+        @options = {
+          :versions => ['v1'],
+          :version_options => {:using => :header, :strict => true}
+        }
+        expect {
+          env = subject.call('HTTP_ACCEPT' => '').last
+        }.to throw_symbol(
+          :error,
+          :status => 406,
+          :headers => {'X-Cascade' => 'pass'},
+          :message => "406 API Version Not Found"
+        )
+      end
+
+      it 'should return a 406 when incorrect header format is used' do
+        @options = {
+          :versions => ['v1'],
+          :version_options => {:using => :header, :strict => true}
+        }
+        expect {
+          env = subject.call('HTTP_ACCEPT' => '*/*').last
+        }.to throw_symbol(
+          :error,
+          :status => 406,
+          :headers => {'X-Cascade' => 'pass'},
+          :message => "406 API Version Not Found"
+        )
+      end
+
+      it 'should return a 200 when proper header is set' do
+        @options = {
+          :versions => ['v1'],
+          :version_options => {:using => :header, :strict => true}
+        }
+        subject.call('HTTP_ACCEPT' => 'application/vnd.testing-v1+json').first.should == 200
+      end
+    end
+
+  end
+
+  context 'vendors' do
+    before do
+      @options = {
+        :version => ['v1'],
+        :version_options => {:using => :header, :vendor => 'vendor'}
+      }
+    end
+
+    it 'should match with correct vendor' do
+      status = subject.call('HTTP_ACCEPT' => accept).first
+      status.should == 200
+    end
+
+    it 'should not match with an incorrect vendor' do
+      expect {
+        env = subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last
+      }.to throw_symbol(:error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found")
+    end
+  end
+
+  context 'no matched version' do
+    before do
+      @options = {
+        :versions => ['unknown_version'],
+        :version_options => {:using => :header}
+      }
+    end
+
+    it 'should throw 406 error with X-Cascade header set to pass' do
+      expect {
+        env = subject.call('HTTP_ACCEPT' => accept).last
+      }.to throw_symbol(:error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found")
+    end
+  end
+end

data/spec/grape/middleware/versioner/path_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Versioner::Path do
+  let(:app) { lambda{|env| [200, env, env['api.version']]} }
+  subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) }
+
+  it 'should set the API version based on the first path' do
+    subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
+  end
+
+  it 'should cut the version out of the path' do
+    subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO'].should == '/awesome'
+  end
+
+  it 'should provide a nil version if no path is given' do
+    subject.call('PATH_INFO' => '/').last.should be_nil
+  end
+
+  context 'with a pattern' do
+    before{ @options = {:pattern => /v./i} }
+    it 'should set the version if it matches' do
+      subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
+    end
+
+    it 'should ignore the version if it fails to match' do
+      subject.call('PATH_INFO' => '/awesome/radical').last.should be_nil
+    end
+  end
+
+  context 'with specified versions' do
+    before{ @options = {:versions => ['v1', 'v2']}}
+    it 'should throw an error if a non-allowed version is specified' do
+      catch(:error){subject.call('PATH_INFO' => '/v3/awesome')}[:status].should == 404
+    end
+
+    it 'should allow versions that have been specified' do
+      subject.call('PATH_INFO' => '/v1/asoasd').last.should == 'v1'
+    end
+  end
+end

data/spec/grape/middleware/versioner_spec.rb

@@ -1,40 +1,12 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner do
-  let(:app) { lambda{|env| [200, env, env['api.version']]} }
-  subject { Grape::Middleware::Versioner.new(app, @options || {}) }
-  
-  it 'should set the API version based on the first path' do
-    subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
+  let(:klass) { Grape::Middleware::Versioner }
+  it 'should recognize :path' do
+    klass.using(:path).should == Grape::Middleware::Versioner::Path
   end
-  
-  it 'should cut the version out of the path' do
-    subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO'].should == '/awesome'
-  end
-  
-  it 'should provide a nil version if no path is given' do
-    subject.call('PATH_INFO' => '/').last.should be_nil
-  end
-  
-  context 'with a pattern' do
-    before{ @options = {:pattern => /v./i} }
-    it 'should set the version if it matches' do
-      subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
-    end
-    
-    it 'should ignore the version if it fails to match' do
-      subject.call('PATH_INFO' => '/awesome/radical').last.should be_nil
-    end
-  end
-  
-  context 'with specified versions' do
-    before{ @options = {:versions => ['v1', 'v2']}}
-    it 'should throw an error if a non-allowed version is specified' do
-      catch(:error){subject.call('PATH_INFO' => '/v3/awesome')}[:status].should == 404
-    end
-    
-    it 'should allow versions that have been specified' do
-      subject.call('PATH_INFO' => '/v1/asoasd').last.should == 'v1'
-    end
+
+  it 'should recognize :header' do
+    klass.using(:header).should == Grape::Middleware::Versioner::Header
   end
 end