grape 1.8.0 → 2.0.0

data/spec/grape/dsl/parameters_spec.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module DSL
-    module ParametersSpec
-      class Dummy
-        include Grape::DSL::Parameters
-        attr_accessor :api, :element, :parent
-
-        def validate_attributes(*args)
-          @validate_attributes = *args
-        end
-
-        def validate_attributes_reader
-          @validate_attributes
-        end
-
-        def push_declared_params(args, **_opts)
-          @push_declared_params = args
-        end
-
-        def push_declared_params_reader
-          @push_declared_params
-        end
-
-        def validates(*args)
-          @validates = *args
-        end
-
-        def validates_reader
-          @validates
-        end
-
-        def new_group_scope(args)
-          @group = args.clone.first
-          yield
-        end
-
-        def extract_message_option(attrs)
-          return nil unless attrs.is_a?(Array)
-
-          opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
-          opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil
-        end
-      end
-    end
-
-    describe Parameters do
-      subject { ParametersSpec::Dummy.new }
-
-      describe '#use' do
-        before do
-          allow_message_expectations_on_nil
-          allow(subject.api).to receive(:namespace_stackable).with(:named_params)
-        end
-
-        let(:options) { { option: 'value' } }
-        let(:named_params) { { params_group: proc {} } }
-
-        it 'calls processes associated with named params' do
-          allow(subject.api).to receive(:namespace_stackable_with_hash).and_return(named_params)
-          expect(subject).to receive(:instance_exec).with(options).and_yield
-          subject.use :params_group, options
-        end
-
-        it 'raises error when non-existent named param is called' do
-          allow(subject.api).to receive(:namespace_stackable_with_hash).and_return({})
-          expect { subject.use :params_group }.to raise_error('Params :params_group not found!')
-        end
-      end
-
-      describe '#use_scope' do
-        it 'is alias to #use' do
-          expect(subject.method(:use_scope)).to eq subject.method(:use)
-        end
-      end
-
-      describe '#includes' do
-        it 'is alias to #use' do
-          expect(subject.method(:includes)).to eq subject.method(:use)
-        end
-      end
-
-      describe '#requires' do
-        it 'adds a required parameter' do
-          subject.requires :id, type: Integer, desc: 'Identity.'
-
-          expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.', presence: { value: true, message: nil } }])
-          expect(subject.push_declared_params_reader).to eq([:id])
-        end
-      end
-
-      describe '#optional' do
-        it 'adds an optional parameter' do
-          subject.optional :id, type: Integer, desc: 'Identity.'
-
-          expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.' }])
-          expect(subject.push_declared_params_reader).to eq([:id])
-        end
-      end
-
-      describe '#with' do
-        it 'creates a scope with group attributes' do
-          subject.with(type: Integer) { subject.optional :id, desc: 'Identity.' }
-
-          expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.' }])
-          expect(subject.push_declared_params_reader).to eq([:id])
-        end
-      end
-
-      describe '#mutually_exclusive' do
-        it 'adds an mutally exclusive parameter validation' do
-          subject.mutually_exclusive :media, :audio
-
-          expect(subject.validates_reader).to eq([%i[media audio], { mutual_exclusion: { value: true, message: nil } }])
-        end
-      end
-
-      describe '#exactly_one_of' do
-        it 'adds an exactly of one parameter validation' do
-          subject.exactly_one_of :media, :audio
-
-          expect(subject.validates_reader).to eq([%i[media audio], { exactly_one_of: { value: true, message: nil } }])
-        end
-      end
-
-      describe '#at_least_one_of' do
-        it 'adds an at least one of parameter validation' do
-          subject.at_least_one_of :media, :audio
-
-          expect(subject.validates_reader).to eq([%i[media audio], { at_least_one_of: { value: true, message: nil } }])
-        end
-      end
-
-      describe '#all_or_none_of' do
-        it 'adds an all or none of parameter validation' do
-          subject.all_or_none_of :media, :audio
-
-          expect(subject.validates_reader).to eq([%i[media audio], { all_or_none_of: { value: true, message: nil } }])
-        end
-      end
-
-      describe '#group' do
-        it 'is alias to #requires' do
-          expect(subject.method(:group)).to eq subject.method(:requires)
-        end
-      end
-
-      describe '#params' do
-        it 'inherits params from parent' do
-          parent_params = { foo: 'bar' }
-          subject.parent = Object.new
-          allow(subject.parent).to receive(:params).and_return(parent_params)
-          expect(subject.params({})).to eq parent_params
-        end
-
-        describe 'when params argument is an array of hashes' do
-          it 'returns values of each hash for @element key' do
-            subject.element = :foo
-            expect(subject.params([{ foo: 'bar' }, { foo: 'baz' }])).to eq(%w[bar baz])
-          end
-        end
-
-        describe 'when params argument is a hash' do
-          it 'returns value for @element key' do
-            subject.element = :foo
-            expect(subject.params(foo: 'bar')).to eq('bar')
-          end
-        end
-
-        describe 'when params argument is not a array or a hash' do
-          it 'returns empty hash' do
-            subject.element = Object.new
-            expect(subject.params(Object.new)).to eq({})
-          end
-        end
-      end
-    end
-  end
-end

data/spec/grape/dsl/request_response_spec.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module DSL
-    module RequestResponseSpec
-      class Dummy
-        include Grape::DSL::RequestResponse
-
-        def self.set(key, value)
-          settings[key.to_sym] = value
-        end
-
-        def self.imbue(key, value)
-          settings.imbue(key, value)
-        end
-      end
-    end
-
-    describe RequestResponse do
-      subject { Class.new(RequestResponseSpec::Dummy) }
-
-      let(:c_type) { 'application/json' }
-      let(:format) { 'txt' }
-
-      describe '.default_format' do
-        it 'sets the default format' do
-          expect(subject).to receive(:namespace_inheritable).with(:default_format, :format)
-          subject.default_format :format
-        end
-
-        it 'returns the format without paramter' do
-          subject.default_format :format
-
-          expect(subject.default_format).to eq :format
-        end
-      end
-
-      describe '.format' do
-        it 'sets a new format' do
-          expect(subject).to receive(:namespace_inheritable).with(:format, format.to_sym)
-          expect(subject).to receive(:namespace_inheritable).with(:default_error_formatter, Grape::ErrorFormatter::Txt)
-
-          subject.format format
-        end
-      end
-
-      describe '.formatter' do
-        it 'sets the formatter for a content type' do
-          expect(subject).to receive(:namespace_stackable).with(:formatters, c_type.to_sym => :formatter)
-          subject.formatter c_type, :formatter
-        end
-      end
-
-      describe '.parser' do
-        it 'sets a parser for a content type' do
-          expect(subject).to receive(:namespace_stackable).with(:parsers, c_type.to_sym => :parser)
-          subject.parser c_type, :parser
-        end
-      end
-
-      describe '.default_error_formatter' do
-        it 'sets a new error formatter' do
-          expect(subject).to receive(:namespace_inheritable).with(:default_error_formatter, Grape::ErrorFormatter::Json)
-          subject.default_error_formatter :json
-        end
-      end
-
-      describe '.error_formatter' do
-        it 'sets a error_formatter' do
-          format = 'txt'
-          expect(subject).to receive(:namespace_stackable).with(:error_formatters, format.to_sym => :error_formatter)
-          subject.error_formatter format, :error_formatter
-        end
-
-        it 'understands syntactic sugar' do
-          expect(subject).to receive(:namespace_stackable).with(:error_formatters, format.to_sym => :error_formatter)
-          subject.error_formatter format, with: :error_formatter
-        end
-      end
-
-      describe '.content_type' do
-        it 'sets a content type for a format' do
-          expect(subject).to receive(:namespace_stackable).with(:content_types, format.to_sym => c_type)
-          subject.content_type format, c_type
-        end
-      end
-
-      describe '.content_types' do
-        it 'returns all content types' do
-          expect(subject.content_types).to eq(xml: 'application/xml',
-                                              serializable_hash: 'application/json',
-                                              json: 'application/json',
-                                              txt: 'text/plain',
-                                              binary: 'application/octet-stream')
-        end
-      end
-
-      describe '.default_error_status' do
-        it 'sets a default error status' do
-          expect(subject).to receive(:namespace_inheritable).with(:default_error_status, 500)
-          subject.default_error_status 500
-        end
-      end
-
-      describe '.rescue_from' do
-        describe ':all' do
-          it 'sets rescue all to true' do
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, nil)
-            subject.rescue_from :all
-          end
-
-          it 'sets given proc as rescue handler' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, rescue_handler_proc)
-            subject.rescue_from :all, rescue_handler_proc
-          end
-
-          it 'sets given block as rescue handler' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, rescue_handler_proc)
-            subject.rescue_from :all, &rescue_handler_proc
-          end
-
-          it 'sets a rescue handler declared through :with option' do
-            with_block = -> { 'hello' }
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, an_instance_of(Proc))
-            subject.rescue_from :all, with: with_block
-          end
-
-          it 'abort if :with option value is not Symbol, String or Proc' do
-            expect { subject.rescue_from :all, with: 1234 }.to raise_error(ArgumentError, "with: #{integer_class_name}, expected Symbol, String or Proc")
-          end
-
-          it 'abort if both :with option and block are passed' do
-            expect do
-              subject.rescue_from :all, with: -> { 'hello' } do
-                error!('bye')
-              end
-            end.to raise_error(ArgumentError, 'both :with option and block cannot be passed')
-          end
-        end
-
-        describe ':grape_exceptions' do
-          it 'sets rescue all to true' do
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
-            expect(subject).to receive(:namespace_inheritable).with(:grape_exceptions_rescue_handler, nil)
-            subject.rescue_from :grape_exceptions
-          end
-
-          it 'sets given proc as rescue handler' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
-            expect(subject).to receive(:namespace_inheritable).with(:grape_exceptions_rescue_handler, rescue_handler_proc)
-            subject.rescue_from :grape_exceptions, rescue_handler_proc
-          end
-
-          it 'sets given block as rescue handler' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
-            expect(subject).to receive(:namespace_inheritable).with(:grape_exceptions_rescue_handler, rescue_handler_proc)
-            subject.rescue_from :grape_exceptions, &rescue_handler_proc
-          end
-
-          it 'sets a rescue handler declared through :with option' do
-            with_block = -> { 'hello' }
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
-            expect(subject).to receive(:namespace_inheritable).with(:grape_exceptions_rescue_handler, an_instance_of(Proc))
-            subject.rescue_from :grape_exceptions, with: with_block
-          end
-        end
-
-        describe 'list of exceptions is passed' do
-          it 'sets hash of exceptions as rescue handlers' do
-            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => nil })
-            expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
-            subject.rescue_from StandardError
-          end
-
-          it 'rescues only base handlers if rescue_subclasses: false option is passed' do
-            expect(subject).to receive(:namespace_reverse_stackable).with(:base_only_rescue_handlers, { StandardError => nil })
-            expect(subject).to receive(:namespace_stackable).with(:rescue_options, { rescue_subclasses: false })
-            subject.rescue_from StandardError, rescue_subclasses: false
-          end
-
-          it 'sets given proc as rescue handler for each key in hash' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => rescue_handler_proc })
-            expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
-            subject.rescue_from StandardError, rescue_handler_proc
-          end
-
-          it 'sets given block as rescue handler for each key in hash' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => rescue_handler_proc })
-            expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
-            subject.rescue_from StandardError, &rescue_handler_proc
-          end
-
-          it 'sets a rescue handler declared through :with option for each key in hash' do
-            with_block = -> { 'hello' }
-            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, { StandardError => an_instance_of(Proc) })
-            expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
-            subject.rescue_from StandardError, with: with_block
-          end
-        end
-      end
-
-      describe '.represent' do
-        it 'sets a presenter for a class' do
-          presenter = Class.new
-          expect(subject).to receive(:namespace_stackable).with(:representations, ThisClass: presenter)
-          subject.represent :ThisClass, with: presenter
-        end
-      end
-    end
-  end
-end

data/spec/grape/dsl/routing_spec.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module DSL
-    module RoutingSpec
-      class Dummy
-        include Grape::DSL::Routing
-      end
-    end
-
-    describe Routing do
-      subject { Class.new(RoutingSpec::Dummy) }
-
-      let(:proc) { -> {} }
-      let(:options) { { a: :b } }
-      let(:path) { '/dummy' }
-
-      describe '.version' do
-        it 'sets a version for route' do
-          version = 'v1'
-          expect(subject).to receive(:namespace_inheritable).with(:version, [version])
-          expect(subject).to receive(:namespace_inheritable).with(:version_options, { using: :path })
-          expect(subject.version(version)).to eq(version)
-        end
-      end
-
-      describe '.prefix' do
-        it 'sets a prefix for route' do
-          prefix = '/api'
-          expect(subject).to receive(:namespace_inheritable).with(:root_prefix, prefix)
-          subject.prefix prefix
-        end
-      end
-
-      describe '.scope' do
-        it 'create a scope without affecting the URL' do
-          expect(subject).to receive(:within_namespace)
-          subject.scope {}
-        end
-      end
-
-      describe '.do_not_route_head!' do
-        it 'sets do not route head option' do
-          expect(subject).to receive(:namespace_inheritable).with(:do_not_route_head, true)
-          subject.do_not_route_head!
-        end
-      end
-
-      describe '.do_not_route_options!' do
-        it 'sets do not route options option' do
-          expect(subject).to receive(:namespace_inheritable).with(:do_not_route_options, true)
-          subject.do_not_route_options!
-        end
-      end
-
-      describe '.mount' do
-        it 'mounts on a nested path' do
-          subject = Class.new(Grape::API)
-          app1 = Class.new(Grape::API)
-          app2 = Class.new(Grape::API)
-          app2.get '/nice' do
-            'play'
-          end
-
-          subject.mount app1 => '/app1'
-          app1.mount app2 => '/app2'
-
-          expect(subject.inheritable_setting.to_hash[:namespace]).to eq({})
-          expect(subject.inheritable_setting.to_hash[:namespace_inheritable]).to eq({})
-          expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1'])
-
-          expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1', '/app2'])
-        end
-
-        it 'mounts multiple routes at once' do
-          base_app = Class.new(Grape::API)
-          app1     = Class.new(Grape::API)
-          app2     = Class.new(Grape::API)
-          base_app.mount(app1 => '/app1', app2 => '/app2')
-
-          expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1'])
-          expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app2'])
-        end
-      end
-
-      describe '.route' do
-        before do
-          allow(subject).to receive(:endpoints).and_return([])
-          allow(subject).to receive(:route_end)
-          allow(subject).to receive(:reset_validations!)
-        end
-
-        it 'marks end of the route' do
-          expect(subject).to receive(:route_end)
-          subject.route(:any)
-        end
-
-        it 'resets validations' do
-          expect(subject).to receive(:reset_validations!)
-          subject.route(:any)
-        end
-
-        it 'defines a new endpoint' do
-          expect { subject.route(:any) }
-            .to change { subject.endpoints.count }.from(0).to(1)
-        end
-
-        it 'does not duplicate identical endpoints' do
-          subject.route(:any)
-          expect { subject.route(:any) }
-            .not_to change(subject.endpoints, :count)
-        end
-
-        it 'generates correct endpoint options' do
-          allow(subject).to receive(:route_setting).with(:description).and_return(fiz: 'baz')
-          allow(subject).to receive(:namespace_stackable_with_hash).and_return(nuz: 'naz')
-
-          expect(Grape::Endpoint).to receive(:new) do |_inheritable_setting, endpoint_options|
-            expect(endpoint_options[:method]).to eq :get
-            expect(endpoint_options[:path]).to eq '/foo'
-            expect(endpoint_options[:for]).to eq subject
-            expect(endpoint_options[:route_options]).to eq(foo: 'bar', fiz: 'baz', params: { nuz: 'naz' })
-          end.and_yield
-
-          subject.route(:get, '/foo', { foo: 'bar' }, &proc {})
-        end
-      end
-
-      describe '.get' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('GET', path, options)
-          subject.get path, options, &proc
-        end
-      end
-
-      describe '.post' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('POST', path, options)
-          subject.post path, options, &proc
-        end
-      end
-
-      describe '.put' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('PUT', path, options)
-          subject.put path, options, &proc
-        end
-      end
-
-      describe '.head' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('HEAD', path, options)
-          subject.head path, options, &proc
-        end
-      end
-
-      describe '.delete' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('DELETE', path, options)
-          subject.delete path, options, &proc
-        end
-      end
-
-      describe '.options' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('OPTIONS', path, options)
-          subject.options path, options, &proc
-        end
-      end
-
-      describe '.patch' do
-        it 'delegates to .route' do
-          expect(subject).to receive(:route).with('PATCH', path, options)
-          subject.patch path, options, &proc
-        end
-      end
-
-      describe '.namespace' do
-        let(:new_namespace) { Object.new }
-
-        it 'creates a new namespace with given name and options' do
-          expect(subject).to receive(:within_namespace).and_yield
-          expect(subject).to receive(:nest).and_yield
-          expect(Namespace).to receive(:new).with(:foo, foo: 'bar').and_return(new_namespace)
-          expect(subject).to receive(:namespace_stackable).with(:namespace, new_namespace)
-
-          subject.namespace :foo, foo: 'bar', &proc {}
-        end
-
-        it 'calls #joined_space_path on Namespace' do
-          result_of_namspace_stackable = Object.new
-          allow(subject).to receive(:namespace_stackable).and_return(result_of_namspace_stackable)
-          expect(Namespace).to receive(:joined_space_path).with(result_of_namspace_stackable)
-          subject.namespace
-        end
-      end
-
-      describe '.group' do
-        it 'is alias to #namespace' do
-          expect(subject.method(:group)).to eq subject.method(:namespace)
-        end
-      end
-
-      describe '.resource' do
-        it 'is alias to #namespace' do
-          expect(subject.method(:resource)).to eq subject.method(:namespace)
-        end
-      end
-
-      describe '.resources' do
-        it 'is alias to #namespace' do
-          expect(subject.method(:resources)).to eq subject.method(:namespace)
-        end
-      end
-
-      describe '.segment' do
-        it 'is alias to #namespace' do
-          expect(subject.method(:segment)).to eq subject.method(:namespace)
-        end
-      end
-
-      describe '.routes' do
-        let(:routes) { Object.new }
-
-        it 'returns value received from #prepare_routes' do
-          expect(subject).to receive(:prepare_routes).and_return(routes)
-          expect(subject.routes).to eq routes
-        end
-
-        context 'when #routes was already called once' do
-          before do
-            allow(subject).to receive(:prepare_routes).and_return(routes)
-            subject.routes
-          end
-
-          it 'does not call prepare_routes again' do
-            expect(subject).not_to receive(:prepare_routes)
-            expect(subject.routes).to eq routes
-          end
-        end
-      end
-
-      describe '.route_param' do
-        let!(:options) { { requirements: regex } }
-        let(:regex) { /(.*)/ }
-
-        it 'calls #namespace with given params' do
-          expect(subject).to receive(:namespace).with(':foo', {}).and_yield
-          subject.route_param('foo', {}, &proc {})
-        end
-
-        it 'nests requirements option under param name' do
-          expect(subject).to receive(:namespace) do |_param, options|
-            expect(options[:requirements][:foo]).to eq regex
-          end
-          subject.route_param('foo', options, &proc {})
-        end
-
-        it 'does not modify options parameter' do
-          allow(subject).to receive(:namespace)
-          expect { subject.route_param('foo', options, &proc {}) }
-            .not_to change { options }
-        end
-      end
-
-      describe '.versions' do
-        it 'returns last defined version' do
-          subject.version 'v1'
-          subject.version 'v2'
-          expect(subject.version).to eq('v2')
-        end
-      end
-    end
-  end
-end