grape 1.8.0 → 2.0.0

data/spec/grape/entity_spec.rb

@@ -1,336 +0,0 @@
-# frozen_string_literal: true
-
-require 'grape_entity'
-
-describe Grape::Entity do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  describe '#present' do
-    it 'sets the object as the body if no options are provided' do
-      inner_body = nil
-      subject.get '/example' do
-        present(abc: 'def')
-        inner_body = body
-      end
-      get '/example'
-      expect(inner_body).to eql(abc: 'def')
-    end
-
-    it 'calls through to the provided entity class if one is given' do
-      entity_mock = Object.new
-      allow(entity_mock).to receive(:represent)
-
-      subject.get '/example' do
-        present Object.new, with: entity_mock
-      end
-      get '/example'
-    end
-
-    it 'pulls a representation from the class options if it exists' do
-      entity = Class.new(described_class)
-      allow(entity).to receive(:represent).and_return('Hiya')
-
-      subject.represent Object, with: entity
-      subject.get '/example' do
-        present Object.new
-      end
-      get '/example'
-      expect(last_response.body).to eq('Hiya')
-    end
-
-    it 'pulls a representation from the class options if the presented object is a collection of objects' do
-      entity = Class.new(described_class)
-      allow(entity).to receive(:represent).and_return('Hiya')
-
-      module EntitySpec
-        class TestObject
-        end
-
-        class FakeCollection
-          def first
-            TestObject.new
-          end
-        end
-      end
-
-      subject.represent EntitySpec::TestObject, with: entity
-      subject.get '/example' do
-        present [EntitySpec::TestObject.new]
-      end
-
-      subject.get '/example2' do
-        present EntitySpec::FakeCollection.new
-      end
-
-      get '/example'
-      expect(last_response.body).to eq('Hiya')
-
-      get '/example2'
-      expect(last_response.body).to eq('Hiya')
-    end
-
-    it 'pulls a representation from the class ancestor if it exists' do
-      entity = Class.new(described_class)
-      allow(entity).to receive(:represent).and_return('Hiya')
-
-      subclass = Class.new(Object)
-
-      subject.represent Object, with: entity
-      subject.get '/example' do
-        present subclass.new
-      end
-      get '/example'
-      expect(last_response.body).to eq('Hiya')
-    end
-
-    it 'automatically uses Klass::Entity if that exists' do
-      some_model = Class.new
-      entity = Class.new(described_class)
-      allow(entity).to receive(:represent).and_return('Auto-detect!')
-
-      some_model.const_set :Entity, entity
-
-      subject.get '/example' do
-        present some_model.new
-      end
-      get '/example'
-      expect(last_response.body).to eq('Auto-detect!')
-    end
-
-    it 'automatically uses Klass::Entity based on the first object in the collection being presented' do
-      some_model = Class.new
-      entity = Class.new(described_class)
-      allow(entity).to receive(:represent).and_return('Auto-detect!')
-
-      some_model.const_set :Entity, entity
-
-      subject.get '/example' do
-        present [some_model.new]
-      end
-      get '/example'
-      expect(last_response.body).to eq('Auto-detect!')
-    end
-
-    it 'does not run autodetection for Entity when explicitly provided' do
-      entity = Class.new(described_class)
-      some_array = []
-
-      subject.get '/example' do
-        present some_array, with: entity
-      end
-
-      expect(some_array).not_to receive(:first)
-      get '/example'
-    end
-
-    it 'does not use #first method on ActiveRecord::Relation to prevent needless sql query' do
-      entity = Class.new(described_class)
-      some_relation = Class.new
-      some_model = Class.new
-
-      allow(entity).to receive(:represent).and_return('Auto-detect!')
-      allow(some_relation).to receive(:first)
-      allow(some_relation).to receive(:klass).and_return(some_model)
-
-      some_model.const_set :Entity, entity
-
-      subject.get '/example' do
-        present some_relation
-      end
-
-      expect(some_relation).not_to receive(:first)
-      get '/example'
-      expect(last_response.body).to eq('Auto-detect!')
-    end
-
-    it 'autodetection does not use Entity if it is not a presenter' do
-      some_model = Class.new
-      entity = Class.new
-
-      some_model.class.const_set :Entity, entity
-
-      subject.get '/example' do
-        present some_model
-      end
-      get '/example'
-      expect(entity).not_to receive(:represent)
-    end
-
-    it 'adds a root key to the output if one is given' do
-      inner_body = nil
-      subject.get '/example' do
-        present({ abc: 'def' }, root: :root)
-        inner_body = body
-      end
-      get '/example'
-      expect(inner_body).to eql(root: { abc: 'def' })
-    end
-
-    %i[json serializable_hash].each do |format|
-      it "presents with #{format}" do
-        entity = Class.new(described_class)
-        entity.root 'examples', 'example'
-        entity.expose :id
-
-        subject.format format
-        subject.get '/example' do
-          c = Class.new do
-            attr_reader :id
-
-            def initialize(id)
-              @id = id
-            end
-          end
-          present c.new(1), with: entity
-        end
-
-        get '/example'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('{"example":{"id":1}}')
-      end
-
-      it "presents with #{format} collection" do
-        entity = Class.new(described_class)
-        entity.root 'examples', 'example'
-        entity.expose :id
-
-        subject.format format
-        subject.get '/examples' do
-          c = Class.new do
-            attr_reader :id
-
-            def initialize(id)
-              @id = id
-            end
-          end
-          examples = [c.new(1), c.new(2)]
-          present examples, with: entity
-        end
-
-        get '/examples'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('{"examples":[{"id":1},{"id":2}]}')
-      end
-    end
-
-    it 'presents with xml' do
-      entity = Class.new(described_class)
-      entity.root 'examples', 'example'
-      entity.expose :name
-
-      subject.format :xml
-
-      subject.get '/example' do
-        c = Class.new do
-          attr_reader :name
-
-          def initialize(args)
-            @name = args[:name] || 'no name set'
-          end
-        end
-        present c.new(name: 'johnnyiller'), with: entity
-      end
-      get '/example'
-      expect(last_response.status).to eq(200)
-      expect(last_response.headers['Content-type']).to eq('application/xml')
-      expect(last_response.body).to eq <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <hash>
-          <example>
-            <name>johnnyiller</name>
-          </example>
-        </hash>
-      XML
-    end
-
-    it 'presents with json' do
-      entity = Class.new(described_class)
-      entity.root 'examples', 'example'
-      entity.expose :name
-
-      subject.format :json
-
-      subject.get '/example' do
-        c = Class.new do
-          attr_reader :name
-
-          def initialize(args)
-            @name = args[:name] || 'no name set'
-          end
-        end
-        present c.new(name: 'johnnyiller'), with: entity
-      end
-      get '/example'
-      expect(last_response.status).to eq(200)
-      expect(last_response.headers['Content-type']).to eq('application/json')
-      expect(last_response.body).to eq('{"example":{"name":"johnnyiller"}}')
-    end
-
-    it 'presents with jsonp utilising Rack::JSONP' do
-      # Include JSONP middleware
-      subject.use Rack::JSONP
-
-      entity = Class.new(described_class)
-      entity.root 'examples', 'example'
-      entity.expose :name
-
-      # Rack::JSONP expects a standard JSON response in UTF-8 format
-      subject.format :json
-      subject.formatter :json, lambda { |object, _|
-        object.to_json.encode('utf-8')
-      }
-
-      subject.get '/example' do
-        c = Class.new do
-          attr_reader :name
-
-          def initialize(args)
-            @name = args[:name] || 'no name set'
-          end
-        end
-
-        present c.new(name: 'johnnyiller'), with: entity
-      end
-
-      get '/example?callback=abcDef'
-      expect(last_response.status).to eq(200)
-      expect(last_response.headers['Content-type']).to eq('application/javascript')
-      expect(last_response.body).to include 'abcDef({"example":{"name":"johnnyiller"}})'
-    end
-
-    context 'present with multiple entities' do
-      it 'present with multiple entities using optional symbol' do
-        user = Class.new do
-          attr_reader :name
-
-          def initialize(args)
-            @name = args[:name] || 'no name set'
-          end
-        end
-        user1 = user.new(name: 'user1')
-        user2 = user.new(name: 'user2')
-
-        entity = Class.new(described_class)
-        entity.expose :name
-
-        subject.format :json
-        subject.get '/example' do
-          present :page, 1
-          present :user1, user1, with: entity
-          present :user2, user2, with: entity
-        end
-        get '/example'
-        expect_response_json = {
-          'page' => 1,
-          'user1' => { 'name' => 'user1' },
-          'user2' => { 'name' => 'user2' }
-        }
-        expect(JSON(last_response.body)).to eq(expect_response_json)
-      end
-    end
-  end
-end

data/spec/grape/exceptions/base_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::Base do
-  describe '#to_s' do
-    subject { described_class.new(message: message).to_s }
-
-    let(:message) { 'a_message' }
-
-    it { is_expected.to eq(message) }
-  end
-
-  describe '#message' do
-    subject { described_class.new(message: message).message }
-
-    let(:message) { 'a_message' }
-
-    it { is_expected.to eq(message) }
-  end
-
-  describe '#compose_message' do
-    subject { described_class.new.send(:compose_message, key, **attributes) }
-
-    let(:key) { :invalid_formatter }
-    let(:attributes) { { klass: String, to_format: 'xml' } }
-
-    after do
-      I18n.enforce_available_locales = true
-      I18n.available_locales = %i[en]
-      I18n.locale = :en
-      I18n.default_locale = :en
-      I18n.reload!
-    end
-
-    context 'when I18n enforces available locales' do
-      before { I18n.enforce_available_locales = true }
-
-      context 'when the fallback locale is available' do
-        before do
-          I18n.available_locales = %i[de en]
-          I18n.default_locale = :de
-        end
-
-        it 'returns the translated message' do
-          expect(subject).to eq('cannot convert String to xml')
-        end
-      end
-
-      context 'when the fallback locale is not available' do
-        before do
-          I18n.available_locales = %i[de jp]
-          I18n.locale = :de
-          I18n.default_locale = :de
-        end
-
-        it 'returns the translation string' do
-          expect(subject).to eq("grape.errors.messages.#{key}")
-        end
-      end
-    end
-
-    context 'when I18n does not enforce available locales' do
-      before { I18n.enforce_available_locales = false }
-
-      context 'when the fallback locale is available' do
-        before { I18n.available_locales = %i[de en] }
-
-        it 'returns the translated message' do
-          expect(subject).to eq('cannot convert String to xml')
-        end
-      end
-
-      context 'when the fallback locale is not available' do
-        before { I18n.available_locales = %i[de jp] }
-
-        it 'returns the translated message' do
-          expect(subject).to eq('cannot convert String to xml')
-        end
-      end
-    end
-  end
-end

data/spec/grape/exceptions/body_parse_errors_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Exceptions::ValidationErrors do
-  context 'api with rescue_from :all handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.rescue_from :all do |_e|
-        rack_response 'message was processed', 400
-      end
-      subject.params do
-        requires :beer
-      end
-      subject.post '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'with content_type json' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to eq('message was processed')
-      end
-    end
-
-    context 'with content_type xml' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to eq('message was processed')
-      end
-    end
-
-    context 'with content_type text' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'text/plain'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to eq('message was processed')
-      end
-    end
-
-    context 'with no specific content_type' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', {}
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to eq('message was processed')
-      end
-    end
-  end
-
-  context 'api with rescue_from :grape_exceptions handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.rescue_from :all do |_e|
-        rack_response 'message was processed', 400
-      end
-      subject.rescue_from :grape_exceptions
-
-      subject.params do
-        requires :beer
-      end
-      subject.post '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'with content_type json' do
-      it 'returns body parsing error message' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to include 'message body does not match declared format'
-      end
-    end
-
-    context 'with content_type xml' do
-      it 'returns body parsing error message' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to include 'message body does not match declared format'
-      end
-    end
-  end
-
-  context 'api with rescue_from :grape_exceptions handler with block' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.rescue_from :grape_exceptions do |e|
-        rack_response "Custom Error Contents, Original Message: #{e.message}", 400
-      end
-
-      subject.params do
-        requires :beer
-      end
-
-      subject.post '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'with content_type json' do
-      it 'returns body parsing error message' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to include 'message body does not match declared format'
-        expect(last_response.body).to include 'Custom Error Contents, Original Message'
-      end
-    end
-
-    context 'with content_type xml' do
-      it 'returns body parsing error message' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to include 'message body does not match declared format'
-        expect(last_response.body).to include 'Custom Error Contents, Original Message'
-      end
-    end
-  end
-
-  context 'api without a rescue handler' do
-    subject { Class.new(Grape::API) }
-
-    before do
-      subject.params do
-        requires :beer
-      end
-      subject.post '/beer' do
-        'beer received'
-      end
-    end
-
-    def app
-      subject
-    end
-
-    context 'and with content_type json' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to include('message body does not match declared format')
-        expect(last_response.body).to include('application/json')
-      end
-    end
-
-    context 'with content_type xml' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to include('message body does not match declared format')
-        expect(last_response.body).to include('application/xml')
-      end
-    end
-
-    context 'with content_type text' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', 'CONTENT_TYPE' => 'text/plain'
-        expect(last_response.status).to eq 400
-        expect(last_response.body).to eq('beer is missing')
-      end
-    end
-
-    context 'and with no specific content_type' do
-      it 'can recover from failed body parsing' do
-        post '/beer', 'test', {}
-        expect(last_response.status).to eq 400
-        # plain response with text/html
-        expect(last_response.body).to eq('beer is missing')
-      end
-    end
-  end
-end