grape 1.8.0 → 4.0.1

data/spec/grape/api/instance_spec.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'shared/versioning_examples'
-
-describe Grape::API::Instance do
-  subject(:an_instance) do
-    Class.new(Grape::API::Instance) do
-      namespace :some_namespace do
-        get 'some_endpoint' do
-          'success'
-        end
-      end
-    end
-  end
-
-  let(:root_api) do
-    to_mount = an_instance
-    Class.new(Grape::API) do
-      mount to_mount
-    end
-  end
-
-  def app
-    root_api
-  end
-
-  context 'when an instance is mounted on the root' do
-    it 'can call the instance endpoint' do
-      get '/some_namespace/some_endpoint'
-      expect(last_response.body).to eq 'success'
-    end
-  end
-
-  context 'when an instance is the root' do
-    let(:root_api) do
-      to_mount = an_instance
-      Class.new(Grape::API::Instance) do
-        mount to_mount
-      end
-    end
-
-    it 'can call the instance endpoint' do
-      get '/some_namespace/some_endpoint'
-      expect(last_response.body).to eq 'success'
-    end
-  end
-
-  context 'top level setting' do
-    it 'does not inherit settings from the superclass (Grape::API::Instance)' do
-      expect(an_instance.top_level_setting.parent).to be_nil
-    end
-  end
-
-  context 'with multiple moutes' do
-    let(:first) do
-      Class.new(Grape::API::Instance) do
-        namespace(:some_namespace) do
-          route :any, '*path' do
-            error!('Not found! (1)', 404)
-          end
-        end
-      end
-    end
-    let(:second) do
-      Class.new(Grape::API::Instance) do
-        namespace(:another_namespace) do
-          route :any, '*path' do
-            error!('Not found! (2)', 404)
-          end
-        end
-      end
-    end
-    let(:root_api) do
-      first_instance = first
-      second_instance = second
-      Class.new(Grape::API) do
-        mount first_instance
-        mount first_instance
-        mount second_instance
-      end
-    end
-
-    it 'does not raise a FrozenError on first instance' do
-      expect { patch '/some_namespace/anything' }.not_to \
-        raise_error
-    end
-
-    it 'responds the correct body at the first instance' do
-      patch '/some_namespace/anything'
-      expect(last_response.body).to eq 'Not found! (1)'
-    end
-
-    it 'does not raise a FrozenError on second instance' do
-      expect { get '/another_namespace/other' }.not_to \
-        raise_error
-    end
-
-    it 'responds the correct body at the second instance' do
-      get '/another_namespace/foobar'
-      expect(last_response.body).to eq 'Not found! (2)'
-    end
-  end
-end

data/spec/grape/api/invalid_format_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  before do
-    subject.namespace do
-      format :json
-      content_type :json, 'application/json'
-      params do
-        requires :id, desc: 'Identifier.'
-      end
-      get ':id' do
-        {
-          id: params[:id],
-          format: params[:format]
-        }
-      end
-    end
-  end
-
-  context 'get' do
-    it 'no format' do
-      get '/foo'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq(::Grape::Json.dump(id: 'foo', format: nil))
-    end
-
-    it 'json format' do
-      get '/foo.json'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq(::Grape::Json.dump(id: 'foo', format: 'json'))
-    end
-
-    it 'invalid format' do
-      get '/foo.invalid'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq(::Grape::Json.dump(id: 'foo', format: 'invalid'))
-    end
-  end
-end

data/spec/grape/api/namespace_parameters_in_route_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  before do
-    subject.namespace :me do
-      namespace :pending do
-        get '/' do
-          'banana'
-        end
-      end
-      put ':id' do
-        params[:id]
-      end
-    end
-  end
-
-  context 'get' do
-    it 'responds without ext' do
-      get '/me/pending'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'banana'
-    end
-  end
-
-  context 'put' do
-    it 'responds' do
-      put '/me/foo'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'foo'
-    end
-  end
-end

data/spec/grape/api/nested_helpers_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API::Helpers do
-  module NestedHelpersSpec
-    module HelperMethods
-      extend Grape::API::Helpers
-      def current_user
-        @current_user ||= params[:current_user]
-      end
-    end
-
-    class Nested < Grape::API
-      resource :level1 do
-        helpers HelperMethods
-
-        get do
-          current_user
-        end
-
-        resource :level2 do
-          get do
-            current_user
-          end
-        end
-      end
-    end
-
-    class Main < Grape::API
-      mount Nested
-    end
-  end
-
-  subject do
-    NestedHelpersSpec::Main
-  end
-
-  def app
-    subject
-  end
-
-  it 'can access helpers from a mounted resource' do
-    get '/level1', current_user: 'hello'
-    expect(last_response.body).to eq('hello')
-  end
-
-  it 'can access helpers from a mounted resource in a nested resource' do
-    get '/level1/level2', current_user: 'world'
-    expect(last_response.body).to eq('world')
-  end
-end

data/spec/grape/api/optional_parameters_in_route_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  before do
-    subject.namespace :api do
-      get ':id(/:ext)' do
-        [params[:id], params[:ext]].compact.join('/')
-      end
-
-      put ':id' do
-        params[:id]
-      end
-    end
-  end
-
-  context 'get' do
-    it 'responds without ext' do
-      get '/api/foo'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'foo'
-    end
-
-    it 'responds with ext' do
-      get '/api/foo/bar'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'foo/bar'
-    end
-  end
-
-  context 'put' do
-    it 'responds' do
-      put '/api/foo'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'foo'
-    end
-  end
-end

data/spec/grape/api/parameters_modification_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  before do
-    subject.namespace :test do
-      params do
-        optional :foo, default: +'-abcdef'
-      end
-      get do
-        params[:foo].slice!(0)
-        params[:foo]
-      end
-    end
-  end
-
-  context 'when route modifies param value' do
-    it 'param default should not change' do
-      get '/test'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'abcdef'
-
-      get '/test'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'abcdef'
-
-      get '/test?foo=-123456'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq '123456'
-
-      get '/test'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'abcdef'
-    end
-  end
-end

data/spec/grape/api/patch_method_helpers_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API::Helpers do
-  module PatchHelpersSpec
-    class PatchPublic < Grape::API
-      format :json
-      version 'public-v1', using: :header, vendor: 'grape'
-
-      get do
-        { ok: 'public' }
-      end
-    end
-
-    module AuthMethods
-      def authenticate!; end
-    end
-
-    class PatchPrivate < Grape::API
-      format :json
-      version 'private-v1', using: :header, vendor: 'grape'
-
-      helpers AuthMethods
-
-      before do
-        authenticate!
-      end
-
-      get do
-        { ok: 'private' }
-      end
-    end
-
-    class Main < Grape::API
-      mount PatchPublic
-      mount PatchPrivate
-    end
-  end
-
-  def app
-    PatchHelpersSpec::Main
-  end
-
-  context 'patch' do
-    it 'public' do
-      patch '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-public-v1+json'
-      expect(last_response.status).to eq 405
-    end
-
-    it 'private' do
-      patch '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-private-v1+json'
-      expect(last_response.status).to eq 405
-    end
-
-    it 'default' do
-      patch '/'
-      expect(last_response.status).to eq 405
-    end
-  end
-
-  context 'default' do
-    it 'public' do
-      get '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-public-v1+json'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq({ ok: 'public' }.to_json)
-    end
-
-    it 'private' do
-      get '/', {}, 'HTTP_ACCEPT' => 'application/vnd.grape-private-v1+json'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq({ ok: 'private' }.to_json)
-    end
-
-    it 'default' do
-      get '/'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq({ ok: 'public' }.to_json)
-    end
-  end
-end

data/spec/grape/api/recognize_path_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API do
-  describe '.recognize_path' do
-    subject { Class.new(described_class) }
-
-    it 'fetches endpoint by given path' do
-      subject.get('/foo/:id') {}
-      subject.get('/bar/:id') {}
-      subject.get('/baz/:id') {}
-
-      actual = subject.recognize_path('/bar/1234').routes[0].origin
-      expect(actual).to eq('/bar/:id')
-    end
-
-    it 'returns nil if given path does not match with registered routes' do
-      subject.get {}
-      expect(subject.recognize_path('/bar/1234')).to be_nil
-    end
-  end
-end

data/spec/grape/api/required_parameters_in_route_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  before do
-    subject.namespace :api do
-      get ':id' do
-        [params[:id], params[:ext]].compact.join('/')
-      end
-
-      put ':something_id' do
-        params[:something_id]
-      end
-    end
-  end
-
-  context 'get' do
-    it 'responds' do
-      get '/api/foo'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'foo'
-    end
-  end
-
-  context 'put' do
-    it 'responds' do
-      put '/api/foo'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'foo'
-    end
-  end
-end

data/spec/grape/api/required_parameters_with_invalid_method_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  before do
-    subject.namespace do
-      params do
-        requires :id, desc: 'Identifier.'
-      end
-      get ':id' do
-      end
-    end
-  end
-
-  context 'post' do
-    it '405' do
-      post '/something'
-      expect(last_response.status).to eq 405
-    end
-  end
-end

data/spec/grape/api/routes_with_requirements_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  context 'get' do
-    it 'routes to a namespace param with dots' do
-      subject.namespace ':ns_with_dots', requirements: { ns_with_dots: %r{[^/]+} } do
-        get '/' do
-          params[:ns_with_dots]
-        end
-      end
-
-      get '/test.id.with.dots'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'test.id.with.dots'
-    end
-
-    it 'routes to a path with multiple params with dots' do
-      subject.get ':id_with_dots/:another_id_with_dots', requirements: { id_with_dots: %r{[^/]+},
-                                                                         another_id_with_dots: %r{[^/]+} } do
-        "#{params[:id_with_dots]}/#{params[:another_id_with_dots]}"
-      end
-
-      get '/test.id/test2.id'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'test.id/test2.id'
-    end
-
-    it 'routes to namespace and path params with dots, with overridden requirements' do
-      subject.namespace ':ns_with_dots', requirements: { ns_with_dots: %r{[^/]+} } do
-        get ':another_id_with_dots',     requirements: { ns_with_dots: %r{[^/]+},
-                                                         another_id_with_dots: %r{[^/]+} } do
-          "#{params[:ns_with_dots]}/#{params[:another_id_with_dots]}"
-        end
-      end
-
-      get '/test.id/test2.id'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'test.id/test2.id'
-    end
-
-    it 'routes to namespace and path params with dots, with merged requirements' do
-      subject.namespace ':ns_with_dots', requirements: { ns_with_dots: %r{[^/]+} } do
-        get ':another_id_with_dots',     requirements: { another_id_with_dots: %r{[^/]+} } do
-          "#{params[:ns_with_dots]}/#{params[:another_id_with_dots]}"
-        end
-      end
-
-      get '/test.id/test2.id'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'test.id/test2.id'
-    end
-  end
-end

data/spec/grape/api/shared_helpers_exactly_one_of_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API::Helpers do
-  let(:app) do
-    Class.new(Grape::API) do
-      helpers Module.new do
-        extend Grape::API::Helpers
-
-        params :drink do
-          optional :beer
-          optional :wine
-          exactly_one_of :beer, :wine
-        end
-      end
-      format :json
-
-      params do
-        requires :orderType, type: String, values: %w[food drink]
-        given orderType: ->(val) { val == 'food' } do
-          optional :pasta
-          optional :pizza
-          exactly_one_of :pasta, :pizza
-        end
-        given orderType: ->(val) { val == 'drink' } do
-          use :drink
-        end
-      end
-      get do
-        declared(params, include_missing: true)
-      end
-    end
-  end
-
-  it 'defines parameters' do
-    get '/', orderType: 'food', pizza: 'mista'
-    expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ orderType: 'food',
-                                       pasta: nil, pizza: 'mista',
-                                       beer: nil, wine: nil }.to_json)
-  end
-end

data/spec/grape/api/shared_helpers_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API::Helpers do
-  subject do
-    shared_params = Module.new do
-      extend Grape::API::Helpers
-
-      params :pagination do
-        optional :page, type: Integer
-        optional :size, type: Integer
-      end
-    end
-
-    Class.new(Grape::API) do
-      helpers shared_params
-      format :json
-
-      params do
-        use :pagination
-      end
-      get do
-        declared(params, include_missing: true)
-      end
-    end
-  end
-
-  def app
-    subject
-  end
-
-  it 'defines parameters' do
-    get '/'
-    expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ page: nil, size: nil }.to_json)
-  end
-end