grape 1.7.1 → 2.0.0

data/spec/grape/middleware/versioner_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Versioner do
-  let(:klass) { described_class }
-
-  it 'recognizes :path' do
-    expect(klass.using(:path)).to eq(Grape::Middleware::Versioner::Path)
-  end
-
-  it 'recognizes :header' do
-    expect(klass.using(:header)).to eq(Grape::Middleware::Versioner::Header)
-  end
-
-  it 'recognizes :param' do
-    expect(klass.using(:param)).to eq(Grape::Middleware::Versioner::Param)
-  end
-
-  it 'recognizes :accept_version_header' do
-    expect(klass.using(:accept_version_header)).to eq(Grape::Middleware::Versioner::AcceptVersionHeader)
-  end
-end

data/spec/grape/named_api_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-describe 'A named API' do
-  subject(:api_name) { NamedAPI.endpoints.last.options[:for].to_s }
-
-  let(:api) do
-    Class.new(Grape::API) do
-      get 'test' do
-        'response'
-      end
-    end
-  end
-
-  before { stub_const('NamedAPI', api) }
-
-  it 'can access the name of the API' do
-    expect(api_name).to eq 'NamedAPI'
-  end
-end

data/spec/grape/parser_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Parser do
-  subject { described_class }
-
-  describe '.builtin_parsers' do
-    it 'returns an instance of Hash' do
-      expect(subject.builtin_parsers).to be_an_instance_of(Hash)
-    end
-
-    it 'includes json and xml parsers by default' do
-      expect(subject.builtin_parsers).to include(json: Grape::Parser::Json, xml: Grape::Parser::Xml)
-    end
-  end
-
-  describe '.parsers' do
-    it 'returns an instance of Hash' do
-      expect(subject.parsers(**{})).to be_an_instance_of(Hash)
-    end
-
-    it 'includes built-in parsers' do
-      expect(subject.parsers(**{})).to include(subject.builtin_parsers)
-    end
-
-    context 'with :parsers option' do
-      let(:parsers) { { customized: Class.new } }
-
-      it 'includes passed :parsers values' do
-        expect(subject.parsers(parsers: parsers)).to include(parsers)
-      end
-    end
-
-    context 'with added parser by using `register` keyword' do
-      let(:added_parser) { Class.new }
-
-      before { subject.register :added, added_parser }
-
-      it 'includes added parser' do
-        expect(subject.parsers(**{})).to include(added: added_parser)
-      end
-    end
-  end
-
-  describe '.parser_for' do
-    let(:options) { {} }
-
-    it 'calls .parsers' do
-      expect(subject).to receive(:parsers).with(any_args).and_return(subject.builtin_parsers)
-      subject.parser_for(:json, **options)
-    end
-
-    it 'returns parser correctly' do
-      expect(subject.parser_for(:json)).to eq(Grape::Parser::Json)
-    end
-
-    context 'when parser is available' do
-      before { subject.register :customized_json, Grape::Parser::Json }
-
-      it 'returns registered parser if available' do
-        expect(subject.parser_for(:customized_json)).to eq(Grape::Parser::Json)
-      end
-    end
-
-    context 'when parser is an instance of Symbol' do
-      before do
-        allow(subject).to receive(:foo).and_return(:bar)
-        subject.register :foo, :foo
-      end
-
-      it 'returns an instance of Method' do
-        expect(subject.parser_for(:foo)).to be_an_instance_of(Method)
-      end
-
-      it 'returns object which can be called' do
-        method = subject.parser_for(:foo)
-        expect(method.call).to eq(:bar)
-      end
-    end
-
-    context 'when parser does not exist' do
-      it 'returns nil' do
-        expect(subject.parser_for(:undefined)).to be_nil
-      end
-    end
-  end
-end

data/spec/grape/path_spec.rb

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  describe Path do
-    describe '#initialize' do
-      it 'remembers the path' do
-        path = described_class.new('/:id', anything, anything)
-        expect(path.raw_path).to eql('/:id')
-      end
-
-      it 'remembers the namespace' do
-        path = described_class.new(anything, '/users', anything)
-        expect(path.namespace).to eql('/users')
-      end
-
-      it 'remebers the settings' do
-        path = described_class.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 = described_class.new(anything, anything, {})
-        expect(path.mount_path).to be_nil
-      end
-
-      it 'is nil when the mount path is nil' do
-        path = described_class.new(anything, anything, mount_path: nil)
-        expect(path.mount_path).to be_nil
-      end
-
-      it 'splits the mount path' do
-        path = described_class.new(anything, anything, mount_path: %w[foo bar])
-        expect(path.mount_path).to eql(%w[foo bar])
-      end
-    end
-
-    describe '#root_prefix' do
-      it 'is nil when no root prefix setting exists' do
-        path = described_class.new(anything, anything, {})
-        expect(path.root_prefix).to be_nil
-      end
-
-      it 'is nil when the mount path is nil' do
-        path = described_class.new(anything, anything, root_prefix: nil)
-        expect(path.root_prefix).to be_nil
-      end
-
-      it 'splits the mount path' do
-        path = described_class.new(anything, anything, root_prefix: 'hello/world')
-        expect(path.root_prefix).to eql(%w[hello world])
-      end
-    end
-
-    describe '#uses_path_versioning?' do
-      it 'is false when the version setting is nil' do
-        path = described_class.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 = described_class.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 = described_class.new(
-          anything,
-          anything,
-          version: 'v1',
-          version_options: { using: :path }
-        )
-
-        expect(path.uses_path_versioning?).to be true
-      end
-    end
-
-    describe '#namespace?' do
-      it 'is false when the namespace is nil' do
-        path = described_class.new(anything, nil, anything)
-        expect(path).not_to be_namespace
-      end
-
-      it 'is false when the namespace starts with whitespace' do
-        path = described_class.new(anything, ' /foo', anything)
-        expect(path).not_to be_namespace
-      end
-
-      it 'is false when the namespace is the root path' do
-        path = described_class.new(anything, '/', anything)
-        expect(path.namespace?).to be false
-      end
-
-      it 'is true otherwise' do
-        path = described_class.new(anything, '/world', anything)
-        expect(path.namespace?).to be true
-      end
-    end
-
-    describe '#path?' do
-      it 'is false when the path is nil' do
-        path = described_class.new(nil, anything, anything)
-        expect(path).not_to be_path
-      end
-
-      it 'is false when the path starts with whitespace' do
-        path = described_class.new(' /foo', anything, anything)
-        expect(path).not_to be_path
-      end
-
-      it 'is false when the path is the root path' do
-        path = described_class.new('/', anything, anything)
-        expect(path.path?).to be false
-      end
-
-      it 'is true otherwise' do
-        path = described_class.new('/hello', anything, anything)
-        expect(path.path?).to be true
-      end
-    end
-
-    describe '#path' do
-      context 'mount_path' do
-        it 'is not included when it is nil' do
-          path = described_class.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 = described_class.new(nil, nil, {})
-          expect(path.path).to eql('/')
-        end
-      end
-
-      context 'root_prefix' do
-        it 'is not included when it is nil' do
-          path = described_class.new(nil, nil, {})
-          expect(path.path).to eql('/')
-        end
-
-        it 'is included after the mount path' do
-          path = described_class.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 = described_class.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 = described_class.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 using a specific format' do
-        it 'accepts specified format' do
-          path = described_class.new(nil, nil, {})
-          allow(path).to receive(:uses_specific_format?).and_return(true)
-          allow(path).to receive(:settings).and_return({ format: :json })
-
-          expect(path.suffix).to eql('(.json)')
-        end
-      end
-
-      context 'when path versioning is used' do
-        it "includes a '/'" do
-          path = described_class.new(nil, nil, {})
-          allow(path).to receive(:uses_specific_format?).and_return(false)
-          allow(path).to receive(:uses_path_versioning?).and_return(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 = described_class.new(nil, 'namespace', {})
-          allow(path).to receive(:uses_specific_format?).and_return(false)
-          allow(path).to receive(:uses_path_versioning?).and_return(true)
-
-          expect(path.suffix).to eql('(.:format)')
-        end
-
-        it "does not include a '/' when the path has a path" do
-          path = described_class.new('/path', nil, {})
-          allow(path).to receive(:uses_specific_format?).and_return(false)
-          allow(path).to receive(:uses_path_versioning?).and_return(true)
-
-          expect(path.suffix).to eql('(.:format)')
-        end
-
-        it "includes a '/' otherwise" do
-          path = described_class.new(nil, nil, {})
-          allow(path).to receive(:uses_specific_format?).and_return(false)
-          allow(path).to receive(:uses_path_versioning?).and_return(true)
-
-          expect(path.suffix).to eql('(/.:format)')
-        end
-      end
-    end
-
-    describe '#path_with_suffix' do
-      it 'combines the path and suffix' do
-        path = described_class.new(nil, nil, {})
-        allow(path).to receive(:path).and_return('/the/path')
-        allow(path).to receive(:suffix).and_return('suffix')
-
-        expect(path.path_with_suffix).to eql('/the/pathsuffix')
-      end
-
-      context 'when using a specific format' do
-        it 'might have a suffix with specified format' do
-          path = described_class.new(nil, nil, {})
-          allow(path).to receive(:path).and_return('/the/path')
-          allow(path).to receive(:uses_specific_format?).and_return(true)
-          allow(path).to receive(:settings).and_return({ format: :json })
-
-          expect(path.path_with_suffix).to eql('/the/path(.json)')
-        end
-      end
-    end
-  end
-end

data/spec/grape/presenters/presenter_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Presenters
-    module PresenterSpec
-      class Dummy
-        include Grape::DSL::InsideRoute
-
-        attr_reader :env, :request, :new_settings
-
-        def initialize
-          @env = {}
-          @header = {}
-          @new_settings = { namespace_inheritable: {}, namespace_stackable: {} }
-        end
-      end
-    end
-
-    describe Presenter do
-      subject { PresenterSpec::Dummy.new }
-
-      describe 'represent' do
-        let(:object_mock) do
-          Object.new
-        end
-
-        it 'represent object' do
-          expect(described_class.represent(object_mock)).to eq object_mock
-        end
-      end
-
-      describe 'present' do
-        let(:hash_mock) do
-          { key: :value }
-        end
-
-        describe 'instance' do
-          before do
-            subject.present hash_mock, with: described_class
-          end
-
-          it 'presents dummy hash' do
-            expect(subject.body).to eq hash_mock
-          end
-        end
-
-        describe 'multiple presenter' do
-          let(:hash_mock1) do
-            { key1: :value1 }
-          end
-
-          let(:hash_mock2) do
-            { key2: :value2 }
-          end
-
-          describe 'instance' do
-            before do
-              subject.present hash_mock1, with: described_class
-              subject.present hash_mock2, with: described_class
-            end
-
-            it 'presents both dummy presenter' do
-              expect(subject.body[:key1]).to eq hash_mock1[:key1]
-              expect(subject.body[:key2]).to eq hash_mock2[:key2]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/grape/request_spec.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  describe Request do
-    let(:default_method) { 'GET' }
-    let(:default_params) { {} }
-    let(:default_options) do
-      {
-        method: method,
-        params: params
-      }
-    end
-    let(:default_env) do
-      Rack::MockRequest.env_for('/', options)
-    end
-    let(:method) { default_method }
-    let(:params) { default_params }
-    let(:options) { default_options }
-    let(:env) { default_env }
-
-    let(:request) do
-      described_class.new(env)
-    end
-
-    describe '#params' do
-      let(:params) do
-        {
-          a: '123',
-          b: 'xyz'
-        }
-      end
-
-      it 'by default returns stringified parameter keys' do
-        expect(request.params).to eq(ActiveSupport::HashWithIndifferentAccess.new('a' => '123', 'b' => 'xyz'))
-      end
-
-      context 'when build_params_with: Grape::Extensions::Hash::ParamBuilder is specified' do
-        let(:request) do
-          described_class.new(env, build_params_with: Grape::Extensions::Hash::ParamBuilder)
-        end
-
-        it 'returns symbolized params' do
-          expect(request.params).to eq(a: '123', b: 'xyz')
-        end
-      end
-
-      describe 'with grape.routing_args' do
-        let(:options) do
-          default_options.merge('grape.routing_args' => routing_args)
-        end
-        let(:routing_args) do
-          {
-            version: '123',
-            route_info: '456',
-            c: 'ccc'
-          }
-        end
-
-        it 'cuts version and route_info' do
-          expect(request.params).to eq(ActiveSupport::HashWithIndifferentAccess.new(a: '123', b: 'xyz', c: 'ccc'))
-        end
-      end
-    end
-
-    describe 'when the param_builder is set to Hashie' do
-      subject(:request_params) { described_class.new(env, **opts).params }
-
-      before do
-        Grape.configure do |config|
-          config.param_builder = Grape::Extensions::Hashie::Mash::ParamBuilder
-        end
-      end
-
-      after do
-        Grape.config.reset
-      end
-
-      context 'when the API does not include a specific param builder' do
-        let(:opts) { {} }
-
-        it { is_expected.to be_a(Hashie::Mash) }
-      end
-
-      context 'when the API includes a specific param builder' do
-        let(:opts) { { build_params_with: Grape::Extensions::Hash::ParamBuilder } }
-
-        it { is_expected.to be_a(Hash) }
-      end
-    end
-
-    describe '#headers' do
-      let(:options) do
-        default_options.merge(request_headers)
-      end
-
-      describe 'with http headers in env' do
-        let(:request_headers) do
-          {
-            'HTTP_X_GRAPE_IS_COOL' => 'yeah'
-          }
-        end
-
-        it 'cuts HTTP_ prefix and capitalizes header name words' do
-          expect(request.headers).to eq('X-Grape-Is-Cool' => 'yeah')
-        end
-      end
-
-      describe 'with non-HTTP_* stuff in env' do
-        let(:request_headers) do
-          {
-            'HTP_X_GRAPE_ENTITY_TOO' => 'but now we are testing Grape'
-          }
-        end
-
-        it 'does not include them' do
-          expect(request.headers).to eq({})
-        end
-      end
-
-      describe 'with symbolic header names' do
-        let(:request_headers) do
-          {
-            HTTP_GRAPE_LIKES_SYMBOLIC: 'it is true'
-          }
-        end
-        let(:env) do
-          default_env.merge(request_headers)
-        end
-
-        it 'converts them to string' do
-          expect(request.headers).to eq('Grape-Likes-Symbolic' => 'it is true')
-        end
-      end
-    end
-  end
-end