grape 0.3.0 → 0.7.0

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Header do
-  let(:app) { lambda{|env| [200, env, env]} }
+  let(:app) { lambda { |env| [200, env, env] } }
   subject { Grape::Middleware::Versioner::Header.new(app, @options || {}) }
 
   before do
     @options = {
-      :version_options => {
-        :using => :header,
-        :vendor => 'vendor',
+      version_options: {
+        using: :header,
+        vendor: 'vendor',
       },
     }
   end
@@ -49,10 +49,10 @@ describe Grape::Middleware::Versioner::Header do
       status.should == 200
     end
 
-    [ 'v1', :v1 ].each do |version|
-      context 'when version is set to #{version{' do
+    ['v1', :v1].each do |version|
+      context 'when version is set to #{version{ ' do
         before do
-          @options[:versions] = [ version ]
+          @options[:versions] = [version]
         end
 
         it 'is set' do
@@ -85,12 +85,12 @@ describe Grape::Middleware::Versioner::Header do
 
     it 'fails with 406 Not Acceptable if vendor is invalid' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor+json').last
+        subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor+json').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {'X-Cascade' => 'pass'},
-        :message => 'API vendor or version not found.'
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'API vendor or version not found.'
       )
     end
 
@@ -113,12 +113,12 @@ describe Grape::Middleware::Versioner::Header do
 
       it 'fails with 406 Not Acceptable if vendor is invalid' do
         expect {
-          env = subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last
+          subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last
         }.to throw_symbol(
           :error,
-          :status => 406,
-          :headers => {'X-Cascade' => 'pass'},
-          :message => 'API vendor or version not found.'
+          status: 406,
+          headers: { 'X-Cascade' => 'pass' },
+          message: 'API vendor or version not found.'
         )
       end
     end
@@ -143,12 +143,12 @@ describe Grape::Middleware::Versioner::Header do
 
     it 'fails with 406 Not Acceptable if version is invalid' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').last
+        subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {'X-Cascade' => 'pass'},
-        :message => 'API vendor or version not found.'
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'API vendor or version not found.'
       )
     end
   end
@@ -172,45 +172,45 @@ describe Grape::Middleware::Versioner::Header do
 
     it 'fails with 406 Not Acceptable if header is not set' do
       expect {
-        env = subject.call({}).last
+        subject.call({}).last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {'X-Cascade' => 'pass'},
-        :message => 'Accept header must be set.'
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'Accept header must be set.'
       )
     end
 
     it 'fails with 406 Not Acceptable if header is empty' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => '').last
+        subject.call('HTTP_ACCEPT' => '').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {'X-Cascade' => 'pass'},
-        :message => 'Accept header must be set.'
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'Accept header must be set.'
       )
     end
 
     it 'fails with 406 Not Acceptable if type is a range' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => '*/*').last
+        subject.call('HTTP_ACCEPT' => '*/*').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {'X-Cascade' => 'pass'},
-        :message => 'Accept header must not contain ranges ("*").'
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'Accept header must not contain ranges ("*").'
       )
     end
 
     it 'fails with 406 Not Acceptable if subtype is a range' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => 'application/*').last
+        subject.call('HTTP_ACCEPT' => 'application/*').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {'X-Cascade' => 'pass'},
-        :message => 'Accept header must not contain ranges ("*").'
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'Accept header must not contain ranges ("*").'
       )
     end
 
@@ -228,45 +228,45 @@ describe Grape::Middleware::Versioner::Header do
 
     it 'fails with 406 Not Acceptable if header is not set' do
       expect {
-        env = subject.call({}).last
+        subject.call({}).last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {},
-        :message => 'Accept header must be set.'
+        status: 406,
+        headers: {},
+        message: 'Accept header must be set.'
       )
     end
 
     it 'fails with 406 Not Acceptable if header is empty' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => '').last
+        subject.call('HTTP_ACCEPT' => '').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {},
-        :message => 'Accept header must be set.'
+        status: 406,
+        headers: {},
+        message: 'Accept header must be set.'
       )
     end
 
     it 'fails with 406 Not Acceptable if type is a range' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => '*/*').last
+        subject.call('HTTP_ACCEPT' => '*/*').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {},
-        :message => 'Accept header must not contain ranges ("*").'
+        status: 406,
+        headers: {},
+        message: 'Accept header must not contain ranges ("*").'
       )
     end
 
     it 'fails with 406 Not Acceptable if subtype is a range' do
       expect {
-        env = subject.call('HTTP_ACCEPT' => 'application/*').last
+        subject.call('HTTP_ACCEPT' => 'application/*').last
       }.to throw_symbol(
         :error,
-        :status => 406,
-        :headers => {},
-        :message => 'Accept header must not contain ranges ("*").'
+        status: 406,
+        headers: {},
+        message: 'Accept header must not contain ranges ("*").'
       )
     end
 
@@ -274,4 +274,29 @@ describe Grape::Middleware::Versioner::Header do
       subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first.should == 200
     end
   end
+
+  context 'when multiple versions are specified' do
+    before do
+      @options[:versions] = ['v1', 'v2']
+    end
+
+    it 'succeeds with v1' do
+      subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first.should == 200
+    end
+
+    it 'succeeds with v2' do
+      subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').first.should == 200
+    end
+
+    it 'fails with another version' do
+      expect {
+        subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v3+json')
+      }.to throw_symbol(
+        :error,
+        status: 406,
+        headers: { 'X-Cascade' => 'pass' },
+        message: 'API vendor or version not found.'
+      )
+    end
+  end
 end

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

@@ -2,16 +2,17 @@ require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Param do
 
-  let(:app) { lambda{|env| [200, env, env['api.version']]} }
+  let(:app) { lambda { |env| [200, env, env['api.version']] } }
   subject { Grape::Middleware::Versioner::Param.new(app, @options || {}) }
 
   it 'sets the API version based on the default param (apiver)' do
-    env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1"}})
+    env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
     subject.call(env)[1]["api.version"].should == 'v1'
   end
 
-  it 'cuts (only) the version out of the params', :focus => true do
-    env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1", "other_param" => "5"}})
+  it 'cuts (only) the version out of the params', focus: true do
+    env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1", "other_param" => "5" })
+    env['rack.request.query_hash'] = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
     subject.call(env)[1]['rack.request.query_hash']["apiver"].should be_nil
     subject.call(env)[1]['rack.request.query_hash']["other_param"].should == "5"
   end
@@ -22,37 +23,36 @@ describe Grape::Middleware::Versioner::Param do
   end
 
   context 'with specified parameter name' do
-    before{ @options = {:parameter => ['v']}}
+    before { @options = { parameter: 'v' } }
     it 'sets the API version based on the custom parameter name' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"v" => "v1"}})
-      s = subject.call(env)[1]["api.version"] == "v1"
+      env = Rack::MockRequest.env_for("/awesome", params: { "v" => "v1" })
+      subject.call(env)[1]["api.version"].should == "v1"
     end
     it 'does not set the API version based on the default param' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1"}})
-      s = subject.call(env)[1]["api.version"] == nil
+      env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
+      subject.call(env)[1]["api.version"].should be_nil
     end
   end
 
   context 'with specified versions' do
-    before{ @options = {:versions => ['v1', 'v2']}}
+    before { @options = { versions: ['v1', 'v2'] } }
     it 'throws an error if a non-allowed version is specified' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v3"}})
-      catch(:error){subject.call(env)}[:status].should == 404
+      env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v3" })
+      catch(:error) { subject.call(env) }[:status].should == 404
     end
-
     it 'allows versions that have been specified' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1"}})
+      env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
       subject.call(env)[1]["api.version"].should == 'v1'
     end
   end
 
   it 'returns a 200 when no version is set (matches the first version found)' do
     @options = {
-      :versions => ['v1'],
-      :version_options => {:using => :header}
+      versions: ['v1'],
+      version_options: { using: :header }
     }
-    env = Rack::MockRequest.env_for("/awesome", {:params => {}})
+    env = Rack::MockRequest.env_for("/awesome", params: {})
     subject.call(env).first.should == 200
   end
 
-end
+end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Path do
-  let(:app) { lambda{|env| [200, env, env['api.version']]} }
+  let(:app) { lambda { |env| [200, env, env['api.version']] } }
   subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) }
 
   it 'sets the API version based on the first path' do
@@ -17,7 +17,7 @@ describe Grape::Middleware::Versioner::Path do
   end
 
   context 'with a pattern' do
-    before { @options = {:pattern => /v./i} }
+    before { @options = { pattern: /v./i } }
     it 'sets the version if it matches' do
       subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
     end
@@ -27,12 +27,12 @@ describe Grape::Middleware::Versioner::Path do
     end
   end
 
-  [ [ 'v1', 'v2'], [ :v1, :v2 ], [ :v1, 'v2' ], [ 'v1', :v2 ] ].each do |versions|
+  [['v1', 'v2'], [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
     context 'with specified versions as #{versions}' do
-      before { @options = { :versions => versions } }
+      before { @options = { versions: versions } }
 
       it 'throws an error if a non-allowed version is specified' do
-        catch(:error){subject.call('PATH_INFO' => '/v3/awesome')}[:status].should == 404
+        catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status].should == 404
       end
 
       it 'allows versions that have been specified' do
@@ -41,4 +41,4 @@ describe Grape::Middleware::Versioner::Path do
     end
   end
 
-end
+end

data/spec/grape/middleware/versioner_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner do
-  
+
   let(:klass) { Grape::Middleware::Versioner }
 
   it 'recognizes :path' do
@@ -16,4 +16,7 @@ describe Grape::Middleware::Versioner do
     klass.using(:param).should == Grape::Middleware::Versioner::Param
   end
 
-end
+  it 'recognizes :accept_version_header' do
+    klass.using(:accept_version_header).should == Grape::Middleware::Versioner::AcceptVersionHeader
+  end
+end

data/spec/grape/path_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+module Grape
+  describe Path do
+
+    describe "#initialize" do
+      it "remembers the path" do
+        path = Path.new('/:id', anything, anything)
+        expect(path.raw_path).to eql('/:id')
+      end
+
+      it "remembers the namespace" do
+        path = Path.new(anything, '/users', anything)
+        expect(path.namespace).to eql('/users')
+      end
+
+      it "remebers the settings" do
+        path = Path.new(anything, anything, foo: 'bar')
+        expect(path.settings).to eql(foo: 'bar')
+      end
+    end
+
+    describe "#mount_path" do
+      it "is nil when no mount path setting exists" do
+        path = Path.new(anything, anything, {})
+        expect(path.mount_path).to be_nil
+      end
+
+      it "is nil when the mount path is nil" do
+        path = Path.new(anything, anything, mount_path: nil)
+        expect(path.mount_path).to be_nil
+      end
+
+      it "splits the mount path" do
+        path = Path.new(anything, anything, mount_path: 'foo/bar')
+        expect(path.mount_path).to eql(['foo', 'bar'])
+      end
+    end
+
+    describe "#root_prefix" do
+      it "is nil when no root prefix setting exists" do
+        path = Path.new(anything, anything, {})
+        expect(path.root_prefix).to be_nil
+      end
+
+      it "is nil when the mount path is nil" do
+        path = Path.new(anything, anything, root_prefix: nil)
+        expect(path.root_prefix).to be_nil
+      end
+
+      it "splits the mount path" do
+        path = Path.new(anything, anything, root_prefix: 'hello/world')
+        expect(path.root_prefix).to eql(['hello', 'world'])
+      end
+    end
+
+    describe "#uses_path_versioning?" do
+      it "is false when the version setting is nil" do
+        path = Path.new(anything, anything, version: nil)
+        expect(path.uses_path_versioning?).to be false
+      end
+
+      it "is false when the version option is header" do
+        path = Path.new(
+          anything,
+          anything,
+          version: 'v1',
+          version_options: { using: :header }
+        )
+
+        expect(path.uses_path_versioning?).to be false
+      end
+
+      it "is true when the version option is path" do
+        path = Path.new(
+          anything,
+          anything,
+          version: 'v1',
+          version_options: { using: :path }
+        )
+
+        expect(path.uses_path_versioning?).to be true
+      end
+    end
+
+    describe "#has_namespace?" do
+      it "is false when the namespace is nil" do
+        path = Path.new(anything, nil, anything)
+        expect(path).not_to have_namespace
+      end
+
+      it "is false when the namespace starts with whitespace" do
+        path = Path.new(anything, ' /foo', anything)
+        expect(path).not_to have_namespace
+      end
+
+      it "is false when the namespace is the root path" do
+        path = Path.new(anything, '/', anything)
+        expect(path).not_to have_namespace
+      end
+
+      it "is true otherwise" do
+        path = Path.new(anything, '/world', anything)
+        expect(path).to have_namespace
+      end
+    end
+
+    describe "#has_path?" do
+      it "is false when the path is nil" do
+        path = Path.new(nil, anything, anything)
+        expect(path).not_to have_path
+      end
+
+      it "is false when the path starts with whitespace" do
+        path = Path.new(' /foo', anything, anything)
+        expect(path).not_to have_path
+      end
+
+      it "is false when the path is the root path" do
+        path = Path.new('/', anything, anything)
+        expect(path).not_to have_path
+      end
+
+      it "is true otherwise" do
+        path = Path.new('/hello', anything, anything)
+        expect(path).to have_path
+      end
+    end
+
+    describe "#path" do
+      context "mount_path" do
+        it "is not included when it is nil" do
+          path = Path.new(nil, nil, mount_path: '/foo/bar')
+          expect(path.path).to eql '/foo/bar'
+        end
+
+        it "is included when it is not nil" do
+          path = Path.new(nil, nil, {})
+          expect(path.path).to eql('/')
+        end
+      end
+
+      context "root_prefix" do
+        it "is not included when it is nil" do
+          path = Path.new(nil, nil, {})
+          expect(path.path).to eql('/')
+        end
+
+        it "is included after the mount path" do
+          path = Path.new(
+            nil,
+            nil,
+            mount_path: '/foo',
+            root_prefix: '/hello'
+          )
+
+          expect(path.path).to eql('/foo/hello')
+        end
+      end
+
+      it "uses the namespace after the mount path and root prefix" do
+        path = Path.new(
+          nil,
+          'namespace',
+          mount_path: '/foo',
+          root_prefix: '/hello'
+        )
+
+        expect(path.path).to eql('/foo/hello/namespace')
+      end
+
+      it "uses the raw path after the namespace" do
+        path = Path.new(
+          'raw_path',
+          'namespace',
+          mount_path: '/foo',
+          root_prefix: '/hello'
+        )
+
+        expect(path.path).to eql('/foo/hello/namespace/raw_path')
+      end
+    end
+
+    describe "#suffix" do
+      context "when path versioning is used" do
+        it "includes a '/'" do
+          path = Path.new(nil, nil, {})
+          path.stub(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(/.:format)')
+        end
+      end
+
+      context "when path versioning is not used" do
+        it "does not include a '/' when the path has a namespace" do
+          path = Path.new(nil, 'namespace', {})
+          path.stub(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(.:format)')
+        end
+
+        it "does not include a '/' when the path has a path" do
+          path = Path.new('/path', nil, {})
+          path.stub(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(.:format)')
+        end
+
+        it "includes a '/' otherwise" do
+          path = Path.new(nil, nil, {})
+          path.stub(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(/.:format)')
+        end
+      end
+    end
+
+    describe "#path_with_suffix" do
+      it "combines the path and suffix" do
+        path = Path.new(nil, nil, {})
+        path.stub(:path) { '/the/path' }
+        path.stub(:suffix) { 'suffix' }
+
+        expect(path.path_with_suffix).to eql('/the/pathsuffix')
+      end
+    end
+
+  end
+end