grape 1.7.1 → 2.0.0

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

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Versioner::AcceptVersionHeader do
-  subject { described_class.new(app, **(@options || {})) }
-
-  let(:app) { ->(env) { [200, env, env] } }
-
-  before do
-    @options = {
-      version_options: {
-        using: :accept_version_header
-      }
-    }
-  end
-
-  context 'api.version' do
-    before do
-      @options[:versions] = ['v1']
-    end
-
-    it 'is set' do
-      status, _, env = subject.call('HTTP_ACCEPT_VERSION' => 'v1')
-      expect(env['api.version']).to eql 'v1'
-      expect(status).to eq(200)
-    end
-
-    it 'is set if format provided' do
-      status, _, env = subject.call('HTTP_ACCEPT_VERSION' => 'v1')
-      expect(env['api.version']).to eql 'v1'
-      expect(status).to eq(200)
-    end
-
-    it 'fails with 406 Not Acceptable if version is not supported' do
-      expect do
-        subject.call('HTTP_ACCEPT_VERSION' => 'v2').last
-      end.to throw_symbol(
-        :error,
-        status: 406,
-        headers: { 'X-Cascade' => 'pass' },
-        message: 'The requested version is not supported.'
-      )
-    end
-  end
-
-  it 'succeeds if :strict is not set' do
-    expect(subject.call('HTTP_ACCEPT_VERSION' => '').first).to eq(200)
-    expect(subject.call({}).first).to eq(200)
-  end
-
-  it 'succeeds if :strict is set to false' do
-    @options[:version_options][:strict] = false
-    expect(subject.call('HTTP_ACCEPT_VERSION' => '').first).to eq(200)
-    expect(subject.call({}).first).to eq(200)
-  end
-
-  context 'when :strict is set' do
-    before do
-      @options[:versions] = ['v1']
-      @options[:version_options][:strict] = true
-    end
-
-    it 'fails with 406 Not Acceptable if header is not set' do
-      expect do
-        subject.call({}).last
-      end.to throw_symbol(
-        :error,
-        status: 406,
-        headers: { 'X-Cascade' => 'pass' },
-        message: 'Accept-Version header must be set.'
-      )
-    end
-
-    it 'fails with 406 Not Acceptable if header is empty' do
-      expect do
-        subject.call('HTTP_ACCEPT_VERSION' => '').last
-      end.to throw_symbol(
-        :error,
-        status: 406,
-        headers: { 'X-Cascade' => 'pass' },
-        message: 'Accept-Version header must be set.'
-      )
-    end
-
-    it 'succeeds if proper header is set' do
-      expect(subject.call('HTTP_ACCEPT_VERSION' => 'v1').first).to eq(200)
-    end
-  end
-
-  context 'when :strict and cascade: false' do
-    before do
-      @options[:versions] = ['v1']
-      @options[:version_options][:strict] = true
-      @options[:version_options][:cascade] = false
-    end
-
-    it 'fails with 406 Not Acceptable if header is not set' do
-      expect do
-        subject.call({}).last
-      end.to throw_symbol(
-        :error,
-        status: 406,
-        headers: {},
-        message: 'Accept-Version header must be set.'
-      )
-    end
-
-    it 'fails with 406 Not Acceptable if header is empty' do
-      expect do
-        subject.call('HTTP_ACCEPT_VERSION' => '').last
-      end.to throw_symbol(
-        :error,
-        status: 406,
-        headers: {},
-        message: 'Accept-Version header must be set.'
-      )
-    end
-
-    it 'succeeds if proper header is set' do
-      expect(subject.call('HTTP_ACCEPT_VERSION' => 'v1').first).to eq(200)
-    end
-  end
-end

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

@@ -1,345 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Versioner::Header do
-  subject { described_class.new(app, **(@options || {})) }
-
-  let(:app) { ->(env) { [200, env, env] } }
-
-  before do
-    @options = {
-      version_options: {
-        using: :header,
-        vendor: 'vendor'
-      }
-    }
-  end
-
-  context 'api.type and api.subtype' do
-    it 'sets type and subtype to first choice of content type if no preference given' do
-      status, _, env = subject.call('HTTP_ACCEPT' => '*/*')
-      expect(env['api.type']).to eql 'application'
-      expect(env['api.subtype']).to eql 'vnd.vendor+xml'
-      expect(status).to eq(200)
-    end
-
-    it 'sets preferred type' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/*')
-      expect(env['api.type']).to eql 'application'
-      expect(env['api.subtype']).to eql 'vnd.vendor+xml'
-      expect(status).to eq(200)
-    end
-
-    it 'sets preferred type and subtype' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'text/plain')
-      expect(env['api.type']).to eql 'text'
-      expect(env['api.subtype']).to eql 'plain'
-      expect(status).to eq(200)
-    end
-  end
-
-  context 'api.format' do
-    it 'is set' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json')
-      expect(env['api.format']).to eql 'json'
-      expect(status).to eq(200)
-    end
-
-    it 'is nil if not provided' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor')
-      expect(env['api.format']).to be_nil
-      expect(status).to eq(200)
-    end
-
-    ['v1', :v1].each do |version|
-      context "when version is set to #{version}" do
-        before do
-          @options[:versions] = [version]
-        end
-
-        it 'is set' do
-          status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json')
-          expect(env['api.format']).to eql 'json'
-          expect(status).to eq(200)
-        end
-
-        it 'is nil if not provided' do
-          status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
-          expect(env['api.format']).to be_nil
-          expect(status).to eq(200)
-        end
-      end
-    end
-  end
-
-  context 'api.vendor' do
-    it 'is set' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor')
-      expect(env['api.vendor']).to eql 'vendor'
-      expect(status).to eq(200)
-    end
-
-    it 'is set if format provided' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json')
-      expect(env['api.vendor']).to eql 'vendor'
-      expect(status).to eq(200)
-    end
-
-    it 'fails with 406 Not Acceptable if vendor is invalid' do
-      expect { subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor+json').last }
-        .to raise_exception do |exception|
-          expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-          expect(exception.headers).to eql('X-Cascade' => 'pass')
-          expect(exception.status).to be 406
-          expect(exception.message).to include 'API vendor not found'
-        end
-    end
-
-    context 'when version is set' do
-      before do
-        @options[:versions] = ['v1']
-      end
-
-      it 'is set' do
-        status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
-        expect(env['api.vendor']).to eql 'vendor'
-        expect(status).to eq(200)
-      end
-
-      it 'is set if format provided' do
-        status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json')
-        expect(env['api.vendor']).to eql 'vendor'
-        expect(status).to eq(200)
-      end
-
-      it 'fails with 406 Not Acceptable if vendor is invalid' do
-        expect { subject.call('HTTP_ACCEPT' => 'application/vnd.othervendor-v1+json').last }
-          .to raise_exception do |exception|
-            expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-            expect(exception.headers).to eql('X-Cascade' => 'pass')
-            expect(exception.status).to be 406
-            expect(exception.message).to include('API vendor not found')
-          end
-      end
-    end
-  end
-
-  context 'api.version' do
-    before do
-      @options[:versions] = ['v1']
-    end
-
-    it 'is set' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1')
-      expect(env['api.version']).to eql 'v1'
-      expect(status).to eq(200)
-    end
-
-    it 'is set if format provided' do
-      status, _, env = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json')
-      expect(env['api.version']).to eql 'v1'
-      expect(status).to eq(200)
-    end
-
-    it 'fails with 406 Not Acceptable if version is invalid' do
-      expect { subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').last }.to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidVersionHeader)
-        expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to be 406
-        expect(exception.message).to include('API version not found')
-      end
-    end
-  end
-
-  it 'succeeds if :strict is not set' do
-    expect(subject.call('HTTP_ACCEPT' => '').first).to eq(200)
-    expect(subject.call({}).first).to eq(200)
-  end
-
-  it 'succeeds if :strict is set to false' do
-    @options[:version_options][:strict] = false
-    expect(subject.call('HTTP_ACCEPT' => '').first).to eq(200)
-    expect(subject.call({}).first).to eq(200)
-  end
-
-  it 'succeeds if :strict is set to false and given an invalid header' do
-    @options[:version_options][:strict] = false
-    expect(subject.call('HTTP_ACCEPT' => 'yaml').first).to eq(200)
-    expect(subject.call({}).first).to eq(200)
-  end
-
-  context 'when :strict is set' do
-    before do
-      @options[:versions] = ['v1']
-      @options[:version_options][:strict] = true
-    end
-
-    it 'fails with 406 Not Acceptable if header is not set' do
-      expect { subject.call({}).last }.to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-        expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to be 406
-        expect(exception.message).to include('Accept header must be set.')
-      end
-    end
-
-    it 'fails with 406 Not Acceptable if header is empty' do
-      expect { subject.call('HTTP_ACCEPT' => '').last }.to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-        expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to be 406
-        expect(exception.message).to include('Accept header must be set.')
-      end
-    end
-
-    it 'succeeds if proper header is set' do
-      expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first).to eq(200)
-    end
-  end
-
-  context 'when :strict and cascade: false' do
-    before do
-      @options[:versions] = ['v1']
-      @options[:version_options][:strict] = true
-      @options[:version_options][:cascade] = false
-    end
-
-    it 'fails with 406 Not Acceptable if header is not set' do
-      expect { subject.call({}).last }.to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-        expect(exception.headers).to eql({})
-        expect(exception.status).to be 406
-        expect(exception.message).to include('Accept header must be set.')
-      end
-    end
-
-    it 'fails with 406 Not Acceptable if header is application/xml' do
-      expect { subject.call('HTTP_ACCEPT' => 'application/xml').last }
-        .to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-        expect(exception.headers).to eql({})
-        expect(exception.status).to be 406
-        expect(exception.message).to include('API vendor or version not found.')
-      end
-    end
-
-    it 'fails with 406 Not Acceptable if header is empty' do
-      expect { subject.call('HTTP_ACCEPT' => '').last }.to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-        expect(exception.headers).to eql({})
-        expect(exception.status).to be 406
-        expect(exception.message).to include('Accept header must be set.')
-      end
-    end
-
-    it 'fails with 406 Not Acceptable if header contains a single invalid accept' do
-      expect { subject.call('HTTP_ACCEPT' => 'application/json;application/vnd.vendor-v1+json').first }
-        .to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidAcceptHeader)
-        expect(exception.headers).to eql({})
-        expect(exception.status).to be 406
-        expect(exception.message).to include('API vendor or version not found.')
-      end
-    end
-
-    it 'succeeds if proper header is set' do
-      expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first).to eq(200)
-    end
-  end
-
-  context 'when multiple versions are specified' do
-    before do
-      @options[:versions] = %w[v1 v2]
-    end
-
-    it 'succeeds with v1' do
-      expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v1+json').first).to eq(200)
-    end
-
-    it 'succeeds with v2' do
-      expect(subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v2+json').first).to eq(200)
-    end
-
-    it 'fails with another version' do
-      expect { subject.call('HTTP_ACCEPT' => 'application/vnd.vendor-v3+json') }.to raise_exception do |exception|
-        expect(exception).to be_a(Grape::Exceptions::InvalidVersionHeader)
-        expect(exception.headers).to eql('X-Cascade' => 'pass')
-        expect(exception.status).to be 406
-        expect(exception.message).to include('API version not found')
-      end
-    end
-  end
-
-  context 'when there are multiple versions with complex vendor specified with rescue_from :all' do
-    subject do
-      Class.new(Grape::API) do
-        rescue_from :all
-      end
-    end
-
-    let(:v1_app) do
-      Class.new(Grape::API) do
-        version 'v1', using: :header, vendor: 'test.a-cool_resource', cascade: false, strict: true
-        content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json'
-        formatter :v1_test, ->(object, _) { object }
-        format :v1_test
-
-        resources :users do
-          get :hello do
-            'one'
-          end
-        end
-      end
-    end
-
-    let(:v2_app) do
-      Class.new(Grape::API) do
-        version 'v2', using: :header, vendor: 'test.a-cool_resource', strict: true
-        content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json'
-        formatter :v2_test, ->(object, _) { object }
-        format :v2_test
-
-        resources :users do
-          get :hello do
-            'two'
-          end
-        end
-      end
-    end
-
-    def app
-      subject.mount v2_app
-      subject.mount v1_app
-      subject
-    end
-
-    context 'with header versioned endpoints and a rescue_all block defined' do
-      it 'responds correctly to a v1 request' do
-        versioned_get '/users/hello', 'v1', using: :header, vendor: 'test.a-cool_resource'
-        expect(last_response.body).to eq('one')
-        expect(last_response.body).not_to include('API vendor or version not found')
-      end
-
-      it 'responds correctly to a v2 request' do
-        versioned_get '/users/hello', 'v2', using: :header, vendor: 'test.a-cool_resource'
-        expect(last_response.body).to eq('two')
-        expect(last_response.body).not_to include('API vendor or version not found')
-      end
-    end
-  end
-
-  context 'with missing vendor option' do
-    subject do
-      Class.new(Grape::API) do
-        version 'v1', using: :header
-      end
-    end
-
-    def app
-      subject
-    end
-
-    it 'fails' do
-      expect { versioned_get '/', 'v1', using: :header }.to raise_error Grape::Exceptions::MissingVendorOption
-    end
-  end
-end

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

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Versioner::Param do
-  subject { described_class.new(app, **options) }
-
-  let(:app) { ->(env) { [200, env, env['api.version']] } }
-  let(:options) { {} }
-
-  it 'sets the API version based on the default param (apiver)' do
-    env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' })
-    expect(subject.call(env)[1]['api.version']).to eq('v1')
-  end
-
-  it 'cuts (only) the version out of the params' 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'])
-    expect(subject.call(env)[1]['rack.request.query_hash']['apiver']).to be_nil
-    expect(subject.call(env)[1]['rack.request.query_hash']['other_param']).to eq('5')
-  end
-
-  it 'provides a nil version if no version is given' do
-    env = Rack::MockRequest.env_for('/')
-    expect(subject.call(env).last).to be_nil
-  end
-
-  context 'with specified parameter name' do
-    let(:options) { { version_options: { parameter: 'v' } } }
-
-    it 'sets the API version based on the custom parameter name' do
-      env = Rack::MockRequest.env_for('/awesome', params: { 'v' => 'v1' })
-      expect(subject.call(env)[1]['api.version']).to eq('v1')
-    end
-
-    it 'does not set the API version based on the default param' do
-      env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' })
-      expect(subject.call(env)[1]['api.version']).to be_nil
-    end
-  end
-
-  context 'with specified versions' do
-    let(:options) { { versions: %w[v1 v2] } }
-
-    it 'throws an error if a non-allowed version is specified' do
-      env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v3' })
-      expect(catch(:error) { subject.call(env) }[:status]).to eq(404)
-    end
-
-    it 'allows versions that have been specified' do
-      env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' })
-      expect(subject.call(env)[1]['api.version']).to eq('v1')
-    end
-  end
-
-  context 'when no version is set' do
-    let(:options) do
-      {
-        versions: ['v1'],
-        version_options: { using: :header }
-      }
-    end
-
-    it 'returns a 200 (matches the first version found)' do
-      env = Rack::MockRequest.env_for('/awesome', params: {})
-      expect(subject.call(env).first).to eq(200)
-    end
-  end
-
-  context 'when there are multiple versions without a custom param' do
-    subject { Class.new(Grape::API) }
-
-    let(:v1_app) do
-      Class.new(Grape::API) do
-        version 'v1', using: :param
-        content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json'
-        formatter :v1_test, ->(object, _) { object }
-        format :v1_test
-
-        resources :users do
-          get :hello do
-            'one'
-          end
-        end
-      end
-    end
-
-    let(:v2_app) do
-      Class.new(Grape::API) do
-        version 'v2', using: :param
-        content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json'
-        formatter :v2_test, ->(object, _) { object }
-        format :v2_test
-
-        resources :users do
-          get :hello do
-            'two'
-          end
-        end
-      end
-    end
-
-    def app
-      subject.mount v2_app
-      subject.mount v1_app
-      subject
-    end
-
-    it 'responds correctly to a v1 request' do
-      versioned_get '/users/hello', 'v1', using: :param, parameter: :apiver
-      expect(last_response.body).to eq('one')
-      expect(last_response.body).not_to include('API vendor or version not found')
-    end
-
-    it 'responds correctly to a v2 request' do
-      versioned_get '/users/hello', 'v2', using: :param, parameter: :apiver
-      expect(last_response.body).to eq('two')
-      expect(last_response.body).not_to include('API vendor or version not found')
-    end
-  end
-
-  context 'when there are multiple versions with a custom param' do
-    subject { Class.new(Grape::API) }
-
-    let(:v1_app) do
-      Class.new(Grape::API) do
-        version 'v1', using: :param, parameter: 'v'
-        content_type :v1_test, 'application/vnd.test.a-cool_resource-v1+json'
-        formatter :v1_test, ->(object, _) { object }
-        format :v1_test
-
-        resources :users do
-          get :hello do
-            'one'
-          end
-        end
-      end
-    end
-
-    let(:v2_app) do
-      Class.new(Grape::API) do
-        version 'v2', using: :param, parameter: 'v'
-        content_type :v2_test, 'application/vnd.test.a-cool_resource-v2+json'
-        formatter :v2_test, ->(object, _) { object }
-        format :v2_test
-
-        resources :users do
-          get :hello do
-            'two'
-          end
-        end
-      end
-    end
-
-    def app
-      subject.mount v2_app
-      subject.mount v1_app
-      subject
-    end
-
-    it 'responds correctly to a v1 request' do
-      versioned_get '/users/hello', 'v1', using: :param, parameter: 'v'
-      expect(last_response.body).to eq('one')
-      expect(last_response.body).not_to include('API vendor or version not found')
-    end
-
-    it 'responds correctly to a v2 request' do
-      versioned_get '/users/hello', 'v2', using: :param, parameter: 'v'
-      expect(last_response.body).to eq('two')
-      expect(last_response.body).not_to include('API vendor or version not found')
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Versioner::Path do
-  subject { described_class.new(app, **options) }
-
-  let(:app) { ->(env) { [200, env, env['api.version']] } }
-  let(:options) { {} }
-
-  it 'sets the API version based on the first path' do
-    expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
-  end
-
-  it 'does not cut the version out of the path' do
-    expect(subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO']).to eq('/v1/awesome')
-  end
-
-  it 'provides a nil version if no path is given' do
-    expect(subject.call('PATH_INFO' => '/').last).to be_nil
-  end
-
-  context 'with a pattern' do
-    let(:options) { { pattern: /v./i } }
-
-    it 'sets the version if it matches' do
-      expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
-    end
-
-    it 'ignores the version if it fails to match' do
-      expect(subject.call('PATH_INFO' => '/awesome/radical').last).to be_nil
-    end
-  end
-
-  [%w[v1 v2], %i[v1 v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
-    context "with specified versions as #{versions}" do
-      let(:options) { { versions: versions } }
-
-      it 'throws an error if a non-allowed version is specified' do
-        expect(catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status]).to eq(404)
-      end
-
-      it 'allows versions that have been specified' do
-        expect(subject.call('PATH_INFO' => '/v1/asoasd').last).to eq('v1')
-      end
-    end
-  end
-
-  context 'with prefix, but requested version is not matched' do
-    let(:options) { { prefix: '/v1', pattern: /v./i } }
-
-    it 'recognizes potential version' do
-      expect(subject.call('PATH_INFO' => '/v3/foo').last).to eq('v3')
-    end
-  end
-
-  context 'with mount path' do
-    let(:options) { { mount_path: '/mounted', versions: [:v1] } }
-
-    it 'recognizes potential version' do
-      expect(subject.call('PATH_INFO' => '/mounted/v1/foo').last).to eq('v1')
-    end
-  end
-end