grape 0.9.0 → 0.10.0

data/spec/grape/util/inheritable_values_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+module Grape
+  module Util
+    describe InheritableValues do
+      let(:parent){ InheritableValues.new }
+      subject { InheritableValues.new(parent) }
+
+      describe '#delete' do
+        it 'deletes a key' do
+          subject[:some_thing] = :new_foo_bar
+          subject.delete :some_thing
+          expect(subject[:some_thing]).to be_nil
+        end
+
+        it 'does not delete parent values' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :new_foo_bar
+          subject.delete :some_thing
+          expect(subject[:some_thing]).to eq :foo
+        end
+      end
+
+      describe '#[]' do
+        it 'returns a value' do
+          subject[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq :foo
+        end
+
+        it 'returns parent value when no value is set' do
+          parent[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq :foo
+        end
+
+        it 'overwrites parent value with the current one' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :foo_bar
+          expect(subject[:some_thing]).to eq :foo_bar
+        end
+
+        it 'parent values are not changed' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :foo_bar
+          expect(parent[:some_thing]).to eq :foo
+        end
+      end
+
+      describe '#[]=' do
+        it 'sets a value' do
+          subject[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq :foo
+        end
+      end
+
+      describe '#to_hash' do
+        it 'returns a Hash representation' do
+          parent[:some_thing] = :foo
+          subject[:some_thing_more] = :foo_bar
+          expect(subject.to_hash).to eq(some_thing: :foo, some_thing_more: :foo_bar)
+        end
+      end
+    end
+  end
+end

data/spec/grape/util/stackable_values_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+module Grape
+  module Util
+    describe StackableValues do
+      let(:parent){ StackableValues.new }
+      subject { StackableValues.new(parent) }
+
+      describe '#keys' do
+        it 'returns all key' do
+          subject[:some_thing] = :foo_bar
+          subject[:some_thing_else] = :foo_bar
+          expect(subject.keys).to eq [:some_thing, :some_thing_else].sort
+        end
+
+        it 'returns merged keys with parent' do
+          parent[:some_thing] = :foo
+          parent[:some_thing_else] = :foo
+
+          subject[:some_thing] = :foo_bar
+          subject[:some_thing_more] = :foo_bar
+
+          expect(subject.keys).to eq [:some_thing, :some_thing_else, :some_thing_more].sort
+        end
+      end
+
+      describe '#delete' do
+        it 'deletes a key' do
+          subject[:some_thing] = :new_foo_bar
+          subject.delete :some_thing
+          expect(subject[:some_thing]).to eq []
+        end
+
+        it 'does not delete parent values' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :new_foo_bar
+          subject.delete :some_thing
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+      end
+
+      describe '#[]' do
+        it 'returns an array of values' do
+          subject[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+
+        it 'returns parent value when no value is set' do
+          parent[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+
+        it 'combines parent and actual values' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :foo_bar
+          expect(subject[:some_thing]).to eq [:foo, :foo_bar]
+        end
+
+        it 'parent values are not changed' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = :foo_bar
+          expect(parent[:some_thing]).to eq [:foo]
+        end
+      end
+
+      describe '#[]=' do
+        it 'sets a value' do
+          subject[:some_thing] = :foo
+          expect(subject[:some_thing]).to eq [:foo]
+        end
+
+        it 'pushes further values' do
+          subject[:some_thing] = :foo
+          subject[:some_thing] = :bar
+          expect(subject[:some_thing]).to eq [:foo, :bar]
+        end
+
+        it 'can handle array values' do
+          subject[:some_thing] = :foo
+          subject[:some_thing] = [:bar, :more]
+          expect(subject[:some_thing]).to eq [:foo, [:bar, :more]]
+
+          parent[:some_thing_else] = [:foo, :bar]
+          subject[:some_thing_else] = [:some, :bar, :foo]
+
+          expect(subject[:some_thing_else]).to eq [[:foo, :bar], [:some, :bar, :foo]]
+        end
+      end
+
+      describe '#to_hash' do
+        it 'returns a Hash representation' do
+          parent[:some_thing] = :foo
+          subject[:some_thing] = [:bar, :more]
+          subject[:some_thing_more] = :foo_bar
+          expect(subject.to_hash).to eq(some_thing: [:foo, [:bar, :more]], some_thing_more: [:foo_bar])
+        end
+      end
+
+      describe '#clone' do
+        let(:obj_cloned) { subject.clone }
+        it 'copies all values' do
+          parent = StackableValues.new
+          child = StackableValues.new parent
+          grandchild = StackableValues.new child
+
+          parent[:some_thing] = :foo
+          child[:some_thing] = [:bar, :more]
+          grandchild[:some_thing] = :grand_foo_bar
+          grandchild[:some_thing_more] = :foo_bar
+
+          expect(grandchild.clone.to_hash).to eq(some_thing: [:foo, [:bar, :more], :grand_foo_bar], some_thing_more: [:foo_bar])
+        end
+      end
+    end
+  end
+end

data/spec/grape/util/strict_hash_configuration_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Grape
+  module Util
+    describe 'StrictHashConfiguration' do
+      subject do
+        Class.new do
+          include Grape::Util::StrictHashConfiguration.module(:config1, :config2, config3: [:config4], config5: [config6: [:config7, :config8]])
+        end
+      end
+
+      it 'set nested configs' do
+        subject.configure do
+          config1 'alpha'
+          config2 'beta'
+
+          config3 do
+            config4 'gamma'
+          end
+
+          local_var = 8
+
+          config5 do
+            config6 do
+              config7 7
+              config8 local_var
+            end
+          end
+        end
+
+        expect(subject.settings).to eq(config1: 'alpha',
+                                       config2: 'beta',
+                                       config3: { config4: 'gamma' },
+                                       config5: { config6: { config7: 7, config8: 8 } }
+                                    )
+      end
+    end
+  end
+end

data/spec/grape/validations/attributes_iterator_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Grape::Validations::AttributesIterator do
+end

data/spec/grape/validations/params_scope_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Grape::Validations::ParamsScope do
+  subject do
+    Class.new(Grape::API)
+  end
+
+  def app
+    subject
+  end
+
+  context 'setting description' do
+    [:desc, :description].each do |description_type|
+      it "allows setting #{description_type}" do
+        subject.params do
+          requires :int, type: Integer, description_type => 'My very nice integer'
+        end
+        subject.get '/single' do
+          'int works'
+        end
+        get '/single', int: 420
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('int works')
+      end
+    end
+  end
+
+  context 'array without coerce type explicitly given' do
+    it 'sets the type based on first element' do
+      subject.params do
+        requires :periods, type: Array, values: -> { %w(day month) }
+      end
+      subject.get('/required') { 'required works' }
+
+      get '/required', periods: %w(day month)
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('required works')
+    end
+
+    it 'fails to call API without Array type' do
+      subject.params do
+        requires :periods, type: Array, values: -> { %w(day month) }
+      end
+      subject.get('/required') { 'required works' }
+
+      get '/required', periods: 'day'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('periods is invalid')
+    end
+
+    it 'raises exception when values are of different type' do
+      expect do
+        subject.params { requires :numbers, type: Array, values: [1, 'definitely not a number', 3] }
+      end.to raise_error Grape::Exceptions::IncompatibleOptionValues
+    end
+  end
+end

data/spec/grape/validations/validators/all_or_none_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Grape::Validations::AllOrNoneOfValidator do
+  describe '#validate!' do
+    let(:scope) do
+      Struct.new(:opts) do
+        def params(arg)
+          arg
+        end
+
+        def required?; end
+      end
+    end
+    let(:all_or_none_params) { [:beer, :wine, :grapefruit] }
+    let(:validator) { described_class.new(all_or_none_params, {}, false, scope.new) }
+
+    context 'when all restricted params are present' do
+      let(:params) { { beer: true, wine: true, grapefruit: true } }
+
+      it 'does not raise a validation exception' do
+        expect(validator.validate!(params)).to eql params
+      end
+
+      context 'mixed with other params' do
+        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+
+        it 'does not raise a validation exception' do
+          expect(validator.validate!(mixed_params)).to eql mixed_params
+        end
+      end
+    end
+
+    context 'when none of the restricted params is selected' do
+      let(:params) { { somethingelse: true } }
+
+      it 'does not raise a validation exception' do
+        expect(validator.validate!(params)).to eql params
+      end
+    end
+
+    context 'when only a subset of restricted params are present' do
+      let(:params) { { beer: true, grapefruit: true } }
+
+      it 'raises a validation exception' do
+        expect do
+          validator.validate! params
+        end.to raise_error(Grape::Exceptions::Validation)
+      end
+      context 'mixed with other params' do
+        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+
+        it 'raise a validation exception' do
+          expect do
+            validator.validate! params
+          end.to raise_error(Grape::Exceptions::Validation)
+        end
+      end
+    end
+  end
+end

data/spec/grape/validations/validators/allow_blank_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Grape::Validations::AllowBlankValidator do
+  module ValidationsSpec
+    module AllowBlankValidatorSpec
+      class API < Grape::API
+        default_format :json
+
+        params do
+          requires :name, allow_blank: false
+        end
+        get
+
+        params do
+          optional :name, allow_blank: false
+        end
+        get '/disallow_blank_optional_param'
+
+        params do
+          requires :name, allow_blank: true
+        end
+        get '/allow_blank'
+
+        params do
+          optional :user, type: Hash do
+            requires :name, allow_blank: false
+          end
+        end
+        get '/disallow_blank_required_param_in_an_optional_group'
+
+        params do
+          optional :user, type: Hash do
+            optional :name, allow_blank: false
+            requires :age
+          end
+        end
+        get '/disallow_blank_optional_param_in_an_optional_group'
+
+        params do
+          requires :user, type: Hash do
+            requires :name, allow_blank: false
+          end
+        end
+        get '/disallow_blank_required_param_in_a_required_group'
+
+        params do
+          requires :user, type: Hash do
+            requires :name, allow_blank: false
+          end
+        end
+        get '/disallow_string_value_in_a_required_hash_group'
+
+        params do
+          requires :user, type: Hash do
+            optional :name, allow_blank: false
+          end
+        end
+        get '/disallow_blank_optional_param_in_a_required_group'
+
+        params do
+          optional :user, type: Hash do
+            optional :name, allow_blank: false
+          end
+        end
+        get '/disallow_string_value_in_an_optional_hash_group'
+      end
+    end
+  end
+
+  def app
+    ValidationsSpec::AllowBlankValidatorSpec::API
+  end
+
+  context 'invalid input' do
+    it 'refuses empty string' do
+      get '/', name: ''
+      expect(last_response.status).to eq(400)
+    end
+
+    it 'refuses only whitespaces' do
+      get '/', name: '   '
+      expect(last_response.status).to eq(400)
+
+      get '/', name: "  \n "
+      expect(last_response.status).to eq(400)
+
+      get '/', name: "\n"
+      expect(last_response.status).to eq(400)
+    end
+
+    it 'refuses nil' do
+      get '/', name: nil
+      expect(last_response.status).to eq(400)
+    end
+  end
+
+  context 'valid input' do
+    it 'accepts valid input' do
+      get '/', name: 'bob'
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'accepts empty input when allow_blank is false' do
+      get '/allow_blank', name: ''
+      expect(last_response.status).to eq(200)
+    end
+  end
+
+  context 'in an optional group' do
+    context 'as a required param' do
+      it 'accepts a missing group, even with a disallwed blank param' do
+        get '/disallow_blank_required_param_in_an_optional_group'
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'refuses a blank value in an existing group' do
+        get '/disallow_blank_required_param_in_an_optional_group', user: { name: '' }
+        expect(last_response.status).to eq(400)
+      end
+    end
+
+    context 'as an optional param' do
+      it 'accepts a missing group, even with a disallwed blank param' do
+        get '/disallow_blank_optional_param_in_an_optional_group'
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts a nested missing optional value' do
+        get '/disallow_blank_optional_param_in_an_optional_group', user: { age: '29' }
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'refuses a blank existing value in an existing scope' do
+        get '/disallow_blank_optional_param_in_an_optional_group', user: { age: '29', name: '' }
+        expect(last_response.status).to eq(400)
+      end
+    end
+  end
+
+  context 'in a required group' do
+    context 'as a required param' do
+      it 'refuses a blank value in a required existing group' do
+        get '/disallow_blank_required_param_in_a_required_group', user: { name: '' }
+        expect(last_response.status).to eq(400)
+      end
+
+      it 'refuses a string value in a required hash group' do
+        get '/disallow_string_value_in_a_required_hash_group', user: ''
+        expect(last_response.status).to eq(400)
+      end
+    end
+
+    context 'as an optional param' do
+      it 'accepts a nested missing value' do
+        get '/disallow_blank_optional_param_in_a_required_group', user: { age: '29' }
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'refuses a blank existing value in an existing scope' do
+        get '/disallow_blank_optional_param_in_a_required_group', user: { age: '29', name: '' }
+        expect(last_response.status).to eq(400)
+      end
+
+      it 'refuses a string value in an optional hash group' do
+        get '/disallow_string_value_in_an_optional_hash_group', user: ''
+        expect(last_response.status).to eq(400)
+      end
+    end
+  end
+end