grape 1.7.1 → 2.0.0

data/spec/grape/extensions/param_builders/hash_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Extensions::Hash::ParamBuilder do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  describe 'in an endpoint' do
-    describe '#params' do
-      before do
-        subject.params do
-          build_with Grape::Extensions::Hash::ParamBuilder # rubocop:disable RSpec/DescribedClass
-        end
-
-        subject.get do
-          params.class
-        end
-      end
-
-      it 'is of type Hash' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Hash')
-      end
-    end
-  end
-
-  describe 'in an api' do
-    before do
-      subject.send(:include, Grape::Extensions::Hash::ParamBuilder) # rubocop:disable RSpec/DescribedClass
-    end
-
-    describe '#params' do
-      before do
-        subject.get do
-          params.class
-        end
-      end
-
-      it 'is Hash' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Hash')
-      end
-    end
-
-    it 'symbolizes params keys' do
-      subject.params do
-        optional :a, type: Hash do
-          optional :b, type: Hash do
-            optional :c, type: String
-          end
-          optional :d, type: Array
-        end
-      end
-
-      subject.get '/foo' do
-        [params[:a][:b][:c], params[:a][:d]]
-      end
-
-      get '/foo', 'a' => { b: { c: 'bar' }, 'd' => ['foo'] }
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('["bar", ["foo"]]')
-    end
-
-    it 'symbolizes the params' do
-      subject.params do
-        build_with Grape::Extensions::Hash::ParamBuilder # rubocop:disable RSpec/DescribedClass
-        requires :a, type: String
-      end
-
-      subject.get '/foo' do
-        [params[:a], params['a']]
-      end
-
-      get '/foo', a: 'bar'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('["bar", nil]')
-    end
-  end
-end

data/spec/grape/extensions/param_builders/hash_with_indifferent_access_spec.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  describe 'in an endpoint' do
-    describe '#params' do
-      before do
-        subject.params do
-          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder # rubocop:disable RSpec/DescribedClass
-        end
-
-        subject.get do
-          params.class
-        end
-      end
-
-      it 'is of type Hash' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('ActiveSupport::HashWithIndifferentAccess')
-      end
-    end
-  end
-
-  describe 'in an api' do
-    before do
-      subject.send(:include, Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder) # rubocop:disable RSpec/DescribedClass
-    end
-
-    describe '#params' do
-      before do
-        subject.get do
-          params.class
-        end
-      end
-
-      it 'is a Hash' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('ActiveSupport::HashWithIndifferentAccess')
-      end
-
-      it 'parses sub hash params' do
-        subject.params do
-          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder # rubocop:disable RSpec/DescribedClass
-
-          optional :a, type: Hash do
-            optional :b, type: Hash do
-              optional :c, type: String
-            end
-            optional :d, type: Array
-          end
-        end
-
-        subject.get '/foo' do
-          [params[:a]['b'][:c], params['a'][:d]]
-        end
-
-        get '/foo', a: { b: { c: 'bar' }, d: ['foo'] }
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('["bar", ["foo"]]')
-      end
-
-      it 'params are indifferent to symbol or string keys' do
-        subject.params do
-          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder # rubocop:disable RSpec/DescribedClass
-          optional :a, type: Hash do
-            optional :b, type: Hash do
-              optional :c, type: String
-            end
-            optional :d, type: Array
-          end
-        end
-
-        subject.get '/foo' do
-          [params[:a]['b'][:c], params['a'][:d]]
-        end
-
-        get '/foo', 'a' => { b: { c: 'bar' }, 'd' => ['foo'] }
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('["bar", ["foo"]]')
-      end
-
-      it 'responds to string keys' do
-        subject.params do
-          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder # rubocop:disable RSpec/DescribedClass
-          requires :a, type: String
-        end
-
-        subject.get '/foo' do
-          [params[:a], params['a']]
-        end
-
-        get '/foo', a: 'bar'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('["bar", "bar"]')
-      end
-    end
-  end
-end

data/spec/grape/extensions/param_builders/hashie/mash_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Extensions::Hashie::Mash::ParamBuilder do
-  subject { Class.new(Grape::API) }
-
-  def app
-    subject
-  end
-
-  describe 'in an endpoint' do
-    describe '#params' do
-      before do
-        subject.params do
-          build_with Grape::Extensions::Hashie::Mash::ParamBuilder # rubocop:disable RSpec/DescribedClass
-        end
-
-        subject.get do
-          params.class
-        end
-      end
-
-      it 'is of type Hashie::Mash' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Hashie::Mash')
-      end
-    end
-  end
-
-  describe 'in an api' do
-    before do
-      subject.send(:include, Grape::Extensions::Hashie::Mash::ParamBuilder) # rubocop:disable RSpec/DescribedClass
-    end
-
-    describe '#params' do
-      before do
-        subject.get do
-          params.class
-        end
-      end
-
-      it 'is Hashie::Mash' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Hashie::Mash')
-      end
-    end
-
-    context 'in a nested namespace api' do
-      before do
-        subject.namespace :foo do
-          get do
-            params.class
-          end
-        end
-      end
-
-      it 'is Hashie::Mash' do
-        get '/foo'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Hashie::Mash')
-      end
-    end
-
-    it 'is indifferent to key or symbol access' do
-      subject.params do
-        build_with Grape::Extensions::Hashie::Mash::ParamBuilder # rubocop:disable RSpec/DescribedClass
-        requires :a, type: String
-      end
-      subject.get '/foo' do
-        [params[:a], params['a']]
-      end
-
-      get '/foo', a: 'bar'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('["bar", "bar"]')
-    end
-  end
-end

data/spec/grape/integration/global_namespace_function_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# see https://github.com/ruby-grape/grape/issues/1348
-
-def namespace
-  raise
-end
-
-describe Grape::API do
-  subject do
-    Class.new(Grape::API) do
-      format :json
-      get do
-        { ok: true }
-      end
-    end
-  end
-
-  def app
-    subject
-  end
-
-  context 'with a global namespace function' do
-    it 'works' do
-      get '/'
-      expect(last_response.status).to eq 200
-    end
-  end
-end

data/spec/grape/integration/rack_sendfile_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-describe Rack::Sendfile do
-  subject do
-    content_object = file_object
-    app = Class.new(Grape::API) do
-      use Rack::Sendfile
-      format :json
-      get do
-        if content_object.is_a?(String)
-          sendfile content_object
-        else
-          stream content_object
-        end
-      end
-    end
-
-    options = {
-      method: 'GET',
-      'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect',
-      'HTTP_X_ACCEL_MAPPING' => '/accel/mapping/=/replaced/'
-    }
-    env = Rack::MockRequest.env_for('/', options)
-    app.call(env)
-  end
-
-  context 'when calling sendfile' do
-    let(:file_object) do
-      '/accel/mapping/some/path'
-    end
-
-    it 'contains Sendfile headers' do
-      headers = subject[1]
-      expect(headers).to include('X-Accel-Redirect')
-    end
-  end
-
-  context 'when streaming non file content' do
-    let(:file_object) do
-      double(:file_object, each: nil)
-    end
-
-    it 'not contains Sendfile headers' do
-      headers = subject[1]
-      expect(headers).not_to include('X-Accel-Redirect')
-    end
-  end
-end

data/spec/grape/integration/rack_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-describe Rack do
-  it 'correctly populates params from a Tempfile' do
-    input = Tempfile.new 'rubbish'
-    begin
-      app = Class.new(Grape::API) do
-        format :json
-        post do
-          { params_keys: params.keys }
-        end
-      end
-      input.write({ test: '123' * 10_000 }.to_json)
-      input.rewind
-      options = {
-        input: input,
-        method: 'POST',
-        'CONTENT_TYPE' => 'application/json'
-      }
-      env = Rack::MockRequest.env_for('/', options)
-
-      expect(JSON.parse(read_chunks(app.call(env)[2]).join)['params_keys']).to match_array('test')
-    ensure
-      input.close
-      input.unlink
-    end
-  end
-
-  context 'when the app is mounted' do
-    let(:ping_mount) do
-      Class.new(Grape::API) do
-        get 'ping'
-      end
-    end
-
-    let(:app) do
-      app_to_mount = ping_mount
-      app = Class.new(Grape::API) do
-        namespace 'namespace' do
-          mount app_to_mount
-        end
-      end
-      Rack::Builder.new(app)
-    end
-
-    it 'finds the app on the namespace' do
-      get '/namespace/ping'
-      expect(last_response.status).to eq 200
-    end
-  end
-end

data/spec/grape/loading_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API do
-  subject do
-    CombinedApi = combined_api
-    Class.new(Grape::API) do
-      format :json
-      mount CombinedApi => '/'
-    end
-  end
-
-  let(:jobs_api) do
-    Class.new(Grape::API) do
-      namespace :one do
-        namespace :two do
-          namespace :three do
-            get :one do
-            end
-            get :two do
-            end
-          end
-        end
-      end
-    end
-  end
-
-  let(:combined_api) do
-    JobsApi = jobs_api
-    Class.new(Grape::API) do
-      version :v1, using: :accept_version_header, cascade: true
-      mount JobsApi
-    end
-  end
-
-  def app
-    subject
-  end
-
-  it 'execute first request in reasonable time' do
-    started = Time.now
-    get '/mount1/nested/test_method'
-    expect(Time.now - started).to be < 5
-  end
-end

data/spec/grape/middleware/auth/base_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-describe Grape::Middleware::Auth::Base do
-  subject do
-    Class.new(Grape::API) do
-      http_basic realm: 'my_realm' do |user, password|
-        user && password && user == password
-      end
-      get '/authorized' do
-        'DONE'
-      end
-    end
-  end
-
-  def app
-    subject
-  end
-
-  it 'authenticates if given valid creds' do
-    get '/authorized', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin')
-    expect(last_response.status).to eq(200)
-    expect(last_response.body).to eq('DONE')
-  end
-
-  it 'throws a 401 is wrong auth is given' do
-    get '/authorized', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong')
-    expect(last_response.status).to eq(401)
-  end
-end

data/spec/grape/middleware/auth/dsl_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Auth::DSL do
-  subject { Class.new(Grape::API) }
-
-  let(:block) { -> {} }
-  let(:settings) do
-    {
-      opaque: 'secret',
-      proc: block,
-      realm: 'API Authorization',
-      type: :http_digest
-    }
-  end
-
-  describe '.auth' do
-    it 'sets auth parameters' do
-      expect(subject.base_instance).to receive(:use).with(Grape::Middleware::Auth::Base, settings)
-
-      subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc]
-      expect(subject.auth).to eq(settings)
-    end
-
-    it 'can be called multiple times' do
-      expect(subject.base_instance).to receive(:use).with(Grape::Middleware::Auth::Base, settings)
-      expect(subject.base_instance).to receive(:use).with(Grape::Middleware::Auth::Base, settings.merge(realm: 'super_secret'))
-
-      subject.auth :http_digest, realm: settings[:realm], opaque: settings[:opaque], &settings[:proc]
-      first_settings = subject.auth
-
-      subject.auth :http_digest, realm: 'super_secret', opaque: settings[:opaque], &settings[:proc]
-
-      expect(subject.auth).to eq(settings.merge(realm: 'super_secret'))
-      expect(subject.auth.object_id).not_to eq(first_settings.object_id)
-    end
-  end
-
-  describe '.http_basic' do
-    it 'sets auth parameters' do
-      subject.http_basic realm: 'my_realm', &settings[:proc]
-      expect(subject.auth).to eq(realm: 'my_realm', type: :http_basic, proc: block)
-    end
-  end
-
-  describe '.http_digest' do
-    context 'when realm is a hash' do
-      it 'sets auth parameters' do
-        subject.http_digest realm: { realm: 'my_realm', opaque: 'my_opaque' }, &settings[:proc]
-        expect(subject.auth).to eq(realm: { realm: 'my_realm', opaque: 'my_opaque' }, type: :http_digest, proc: block)
-      end
-    end
-
-    context 'when realm is not hash' do
-      it 'sets auth parameters' do
-        subject.http_digest realm: 'my_realm', opaque: 'my_opaque', &settings[:proc]
-        expect(subject.auth).to eq(realm: 'my_realm', type: :http_digest, proc: block, opaque: 'my_opaque')
-      end
-    end
-  end
-end

data/spec/grape/middleware/auth/strategies_spec.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-describe Grape::Middleware::Auth::Strategies do
-  context 'Basic Auth' do
-    def app
-      proc = ->(u, p) { u && p && u == p }
-      Rack::Builder.new do |b|
-        b.use Grape::Middleware::Error
-        b.use(Grape::Middleware::Auth::Base, type: :http_basic, proc: proc)
-        b.run ->(_env) { [200, {}, ['Hello there.']] }
-      end
-    end
-
-    it 'throws a 401 if no auth is given' do
-      @proc = -> { false }
-      get '/whatever'
-      expect(last_response.status).to eq(401)
-    end
-
-    it 'authenticates if given valid creds' do
-      get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'admin')
-      expect(last_response.status).to eq(200)
-    end
-
-    it 'throws a 401 is wrong auth is given' do
-      get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('admin', 'wrong')
-      expect(last_response.status).to eq(401)
-    end
-  end
-
-  context 'Digest MD5 Auth' do
-    RSpec::Matchers.define :be_challenge do
-      match do |actual_response|
-        actual_response.status == 401 &&
-          actual_response['WWW-Authenticate'].start_with?('Digest ') &&
-          actual_response.body.empty?
-      end
-    end
-
-    module StrategiesSpec
-      class PasswordHashed < Grape::API
-        http_digest(realm: { realm: 'Test Api', opaque: 'secret', passwords_hashed: true }) do |username|
-          { 'foo' => Digest::MD5.hexdigest(['foo', 'Test Api', 'bar'].join(':')) }[username]
-        end
-
-        get '/test' do
-          [{ hey: 'you' }, { there: 'bar' }, { foo: 'baz' }]
-        end
-      end
-
-      class PasswordIsNotHashed < Grape::API
-        http_digest(realm: 'Test Api', opaque: 'secret') do |username|
-          { 'foo' => 'bar' }[username]
-        end
-
-        get '/test' do
-          [{ hey: 'you' }, { there: 'bar' }, { foo: 'baz' }]
-        end
-      end
-    end
-
-    context 'when password is hashed' do
-      def app
-        StrategiesSpec::PasswordHashed
-      end
-
-      it 'is a digest authentication challenge' do
-        get '/test'
-        expect(last_response).to be_challenge
-      end
-
-      it 'throws a 401 if no auth is given' do
-        get '/test'
-        expect(last_response.status).to eq(401)
-      end
-
-      it 'authenticates if given valid creds' do
-        digest_authorize 'foo', 'bar'
-        get '/test'
-        expect(last_response.status).to eq(200)
-      end
-
-      it 'throws a 401 if given invalid creds' do
-        digest_authorize 'bar', 'foo'
-        get '/test'
-        expect(last_response.status).to eq(401)
-      end
-    end
-
-    context 'when password is not hashed' do
-      def app
-        StrategiesSpec::PasswordIsNotHashed
-      end
-
-      it 'is a digest authentication challenge' do
-        get '/test'
-        expect(last_response).to be_challenge
-      end
-
-      it 'throws a 401 if no auth is given' do
-        get '/test'
-        expect(last_response.status).to eq(401)
-      end
-
-      it 'authenticates if given valid creds' do
-        digest_authorize 'foo', 'bar'
-        get '/test'
-        expect(last_response.status).to eq(200)
-      end
-
-      it 'throws a 401 if given invalid creds' do
-        digest_authorize 'bar', 'foo'
-        get '/test'
-        expect(last_response.status).to eq(401)
-      end
-    end
-  end
-end