grape 1.7.1 → 2.0.0

data/spec/grape/exceptions/invalid_accept_header_spec.rb

@@ -1,358 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::InvalidAcceptHeader do
-  shared_examples_for 'a valid request' do
-    it 'does return with status 200' do
-      expect(last_response.status).to eq 200
-    end
-
-    it 'does return the expected result' do
-      expect(last_response.body).to eq('beer received')
-    end
-  end
-
-  shared_examples_for 'a cascaded request' do
-    it 'does not find a matching route' do
-      expect(last_response.status).to eq 404
-    end
-  end
-
-  shared_examples_for 'a not-cascaded request' do
-    it 'does not include the X-Cascade=pass header' do
-      expect(last_response.headers['X-Cascade']).to be_nil
-    end
-
-    it 'does not accept the request' do
-      expect(last_response.status).to eq 406
-    end
-  end
-
-  shared_examples_for 'a rescued request' do
-    it 'does not include the X-Cascade=pass header' do
-      expect(last_response.headers['X-Cascade']).to be_nil
-    end
-
-    it 'does show rescue handler processing' do
-      expect(last_response.status).to eq 400
-      expect(last_response.body).to eq('message was processed')
-    end
-  end
-
-  context 'API with cascade=false and rescue_from :all handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false
-      subject.rescue_from :all do |e|
-        rack_response 'message was processed', 400, e[:headers]
-      end
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid vendor in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-
-        it_behaves_like 'a rescued request'
-      end
-    end
-  end
-
-  context 'API with cascade=false and without a rescue handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid version in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' }
-
-        it_behaves_like 'a not-cascaded request'
-      end
-
-      context 'an invalid vendor in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' }
-
-        it_behaves_like 'a not-cascaded request'
-      end
-    end
-  end
-
-  context 'API with cascade=false and with rescue_from :all handler and http_codes' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false
-      subject.rescue_from :all do |e|
-        rack_response 'message was processed', 400, e[:headers]
-      end
-      subject.desc 'Get beer' do
-        failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'],
-                 [404, 'Resource not found'], [406, 'API vendor or version not found'],
-                 [500, 'Internal processing error']]
-      end
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid vendor in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-
-        it_behaves_like 'a rescued request'
-      end
-    end
-  end
-
-  context 'API with cascade=false, http_codes but without a rescue handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: false
-      subject.desc 'Get beer' do
-        failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'],
-                 [404, 'Resource not found'], [406, 'API vendor or version not found'],
-                 [500, 'Internal processing error']]
-      end
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid version in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' }
-
-        it_behaves_like 'a not-cascaded request'
-      end
-
-      context 'an invalid vendor in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' }
-
-        it_behaves_like 'a not-cascaded request'
-      end
-    end
-  end
-
-  context 'API with cascade=true and rescue_from :all handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true
-      subject.rescue_from :all do |e|
-        rack_response 'message was processed', 400, e[:headers]
-      end
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid version in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-
-        it_behaves_like 'a cascaded request'
-      end
-
-      context 'an invalid vendor in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-
-        it_behaves_like 'a cascaded request'
-      end
-    end
-  end
-
-  context 'API with cascade=true and without a rescue handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid version in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' }
-
-        it_behaves_like 'a cascaded request'
-      end
-
-      context 'an invalid vendor in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' }
-
-        it_behaves_like 'a cascaded request'
-      end
-    end
-  end
-
-  context 'API with cascade=true and with rescue_from :all handler and http_codes' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true
-      subject.rescue_from :all do |e|
-        rack_response 'message was processed', 400, e[:headers]
-      end
-      subject.desc 'Get beer' do
-        failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'],
-                 [404, 'Resource not found'], [406, 'API vendor or version not found'],
-                 [500, 'Internal processing error']]
-      end
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid version in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-
-        it_behaves_like 'a cascaded request'
-      end
-
-      context 'an invalid vendor in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-
-        it_behaves_like 'a cascaded request'
-      end
-    end
-  end
-
-  context 'API with cascade=true, http_codes but without a rescue handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.version 'v99', using: :header, vendor: 'vendorname', format: :json, cascade: true
-      subject.desc 'Get beer' do
-        failure [[400, 'Bad Request'], [401, 'Unauthorized'], [403, 'Forbidden'],
-                 [404, 'Resource not found'], [406, 'API vendor or version not found'],
-                 [500, 'Internal processing error']]
-      end
-      subject.get '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'that received a request with correct vendor and version' do
-      before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v99' }
-
-      it_behaves_like 'a valid request'
-    end
-
-    context 'that receives' do
-      context 'an invalid version in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' }
-
-        it_behaves_like 'a cascaded request'
-      end
-
-      context 'an invalid vendor in the request' do
-        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99' }
-
-        it_behaves_like 'a cascaded request'
-      end
-    end
-  end
-end

data/spec/grape/exceptions/invalid_formatter_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::InvalidFormatter do
-  describe '#message' do
-    let(:error) do
-      described_class.new(String, 'xml')
-    end
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include(
-        'cannot convert String to xml'
-      )
-    end
-  end
-end

data/spec/grape/exceptions/invalid_response_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::InvalidResponse do
-  describe '#message' do
-    let(:error) { described_class.new }
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include('Invalid response')
-    end
-  end
-end

data/spec/grape/exceptions/invalid_versioner_option_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::InvalidVersionerOption do
-  describe '#message' do
-    let(:error) do
-      described_class.new('headers')
-    end
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include(
-        'unknown :using for versioner: headers'
-      )
-    end
-  end
-end

data/spec/grape/exceptions/missing_group_type_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Grape::Exceptions::MissingGroupType do
-  describe '#message' do
-    subject { described_class.new.message }
-
-    it { is_expected.to include 'group type is required' }
-  end
-
-  describe 'deprecated Grape::Exceptions::MissingGroupTypeError' do
-    subject { Grape::Exceptions::MissingGroupTypeError.new }
-
-    it 'puts a deprecation warning' do
-      expect(Warning).to receive(:warn) do |message|
-        expect(message).to include('`Grape::Exceptions::MissingGroupTypeError` is deprecated')
-      end
-
-      subject
-    end
-  end
-end

data/spec/grape/exceptions/missing_mime_type_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::MissingMimeType do
-  describe '#message' do
-    let(:error) do
-      described_class.new('new_json')
-    end
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include 'missing mime type for new_json'
-    end
-
-    it 'contains the resolution in the message' do
-      expect(error.message).to include "or add your own with content_type :new_json, 'application/new_json' "
-    end
-  end
-end

data/spec/grape/exceptions/missing_option_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::MissingOption do
-  describe '#message' do
-    let(:error) do
-      described_class.new(:path)
-    end
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include(
-        'you must specify :path options'
-      )
-    end
-  end
-end

data/spec/grape/exceptions/unknown_options_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::UnknownOptions do
-  describe '#message' do
-    let(:error) do
-      described_class.new(%i[a b])
-    end
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include(
-        'unknown options: '
-      )
-    end
-  end
-end

data/spec/grape/exceptions/unknown_validator_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::UnknownValidator do
-  describe '#message' do
-    let(:error) do
-      described_class.new('gt_10')
-    end
-
-    it 'contains the problem in the message' do
-      expect(error.message).to include(
-        'unknown validator: gt_10'
-      )
-    end
-  end
-end

data/spec/grape/exceptions/unsupported_group_type_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Grape::Exceptions::UnsupportedGroupType do
-  subject { described_class.new }
-
-  describe '#message' do
-    subject { described_class.new.message }
-
-    it { is_expected.to include 'group type must be Array, Hash, JSON or Array[JSON]' }
-  end
-
-  describe 'deprecated Grape::Exceptions::UnsupportedGroupTypeError' do
-    subject { Grape::Exceptions::UnsupportedGroupTypeError.new }
-
-    it 'puts a deprecation warning' do
-      expect(Warning).to receive(:warn) do |message|
-        expect(message).to include('`Grape::Exceptions::UnsupportedGroupTypeError` is deprecated')
-      end
-
-      subject
-    end
-  end
-end

data/spec/grape/exceptions/validation_errors_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-
-describe Grape::Exceptions::ValidationErrors do
-  let(:validation_message) { 'FooBar is invalid' }
-  let(:validation_error) { instance_double Grape::Exceptions::Validation, params: [validation_message], message: '' }
-
-  context 'initialize' do
-    subject do
-      described_class.new(errors: [validation_error], headers: headers)
-    end
-
-    let(:headers) do
-      {
-        'A-Header-Key' => 'A-Header-Value'
-      }
-    end
-
-    it 'assigns headers through base class' do
-      expect(subject.headers).to eq(headers)
-    end
-  end
-
-  context 'message' do
-    context 'is not repeated' do
-      subject(:message) { error.message.split(',').map(&:strip) }
-
-      let(:error) do
-        described_class.new(errors: [validation_error, validation_error])
-      end
-
-      it { expect(message).to include validation_message }
-      it { expect(message.size).to eq 1 }
-    end
-  end
-
-  describe '#full_messages' do
-    context 'with errors' do
-      subject { described_class.new(errors: [validation_error_1, validation_error_2]).full_messages }
-
-      let(:validation_error_1) { Grape::Exceptions::Validation.new(params: ['id'], message: :presence) }
-      let(:validation_error_2) { Grape::Exceptions::Validation.new(params: ['name'], message: :presence) }
-
-      it 'returns an array with each errors full message' do
-        expect(subject).to contain_exactly('id is missing', 'name is missing')
-      end
-    end
-
-    context 'when attributes is an array of symbols' do
-      subject { described_class.new(errors: [validation_error]).full_messages }
-
-      let(:validation_error) { Grape::Exceptions::Validation.new(params: [:admin_field], message: 'Can not set admin-only field') }
-
-      it 'returns an array with an error full message' do
-        expect(subject.first).to eq('admin_field Can not set admin-only field')
-      end
-    end
-  end
-
-  context 'api' do
-    subject { Class.new(Grape::API) }
-
-    def app
-      subject
-    end
-
-    it 'can return structured json with separate fields' do
-      subject.format :json
-      subject.rescue_from described_class do |e|
-        error!(e, 400)
-      end
-      subject.params do
-        optional :beer
-        optional :wine
-        optional :juice
-        exactly_one_of :beer, :wine, :juice
-      end
-      subject.get '/exactly_one_of' do
-        'exactly_one_of works!'
-      end
-      get '/exactly_one_of', beer: 'string', wine: 'anotherstring'
-      expect(last_response.status).to eq(400)
-      expect(JSON.parse(last_response.body)).to eq(
-        [
-          'params' => %w[beer wine],
-          'messages' => ['are mutually exclusive']
-        ]
-      )
-    end
-  end
-end

data/spec/grape/exceptions/validation_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::Validation do
-  it 'fails when params are missing' do
-    expect { described_class.new(message: 'presence') }.to raise_error(ArgumentError, /missing keyword:.+?params/)
-  end
-
-  context 'when message is a symbol' do
-    it 'stores message_key' do
-      expect(described_class.new(params: ['id'], message: :presence).message_key).to eq(:presence)
-    end
-  end
-
-  context 'when message is a String' do
-    it 'does not store the message_key' do
-      expect(described_class.new(params: ['id'], message: 'presence').message_key).to be_nil
-    end
-  end
-end