grape 1.7.1 → 2.0.0

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::SingleAttributeIterator do
-  describe '#each' do
-    subject(:iterator) { described_class.new(validator, scope, params) }
-
-    let(:scope) { Grape::Validations::ParamsScope.new(api: Class.new(Grape::API)) }
-    let(:validator) { double(attrs: %i[first second]) }
-
-    context 'when params is a hash' do
-      let(:params) do
-        { first: 'string', second: 'string' }
-      end
-
-      it 'yields params and every single attribute from the list' do
-        expect { |b| iterator.each(&b) }
-          .to yield_successive_args([params, :first, false, false], [params, :second, false, false])
-      end
-    end
-
-    context 'when params is an array' do
-      let(:params) do
-        [{ first: 'string1', second: 'string1' }, { first: 'string2', second: 'string2' }]
-      end
-
-      it 'yields every single attribute from the list for each of the array elements' do
-        expect { |b| iterator.each(&b) }.to yield_successive_args(
-          [params[0], :first, false, false], [params[0], :second, false, false],
-          [params[1], :first, false, false], [params[1], :second, false, false]
-        )
-      end
-
-      context 'empty values' do
-        let(:params) { [{}, '', 10] }
-
-        it 'marks params with empty values' do
-          expect { |b| iterator.each(&b) }.to yield_successive_args(
-            [params[0], :first, true, false], [params[0], :second, true, false],
-            [params[1], :first, true, false], [params[1], :second, true, false],
-            [params[2], :first, false, false], [params[2], :second, false, false]
-          )
-        end
-      end
-
-      context 'when missing optional value' do
-        let(:params) { [Grape::DSL::Parameters::EmptyOptionalValue, 10] }
-
-        it 'marks params with skipped values' do
-          expect { |b| iterator.each(&b) }.to yield_successive_args(
-            [params[0], :first, false, true], [params[0], :second, false, true],
-            [params[1], :first, false, false], [params[1], :second, false, false]
-          )
-        end
-      end
-    end
-  end
-end

data/spec/grape/validations/types/array_coercer_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::Types::ArrayCoercer do
-  subject { described_class.new(type) }
-
-  describe '#call' do
-    context 'an array of primitives' do
-      let(:type) { Array[String] }
-
-      it 'coerces elements in the array' do
-        expect(subject.call([10, 20])).to eq(%w[10 20])
-      end
-    end
-
-    context 'an array of arrays' do
-      let(:type) { Array[Array[Integer]] }
-
-      it 'coerces elements in the nested array' do
-        expect(subject.call([%w[10 20]])).to eq([[10, 20]])
-        expect(subject.call([['10'], ['20']])).to eq([[10], [20]])
-      end
-    end
-
-    context 'an array of sets' do
-      let(:type) { Array[Set[Integer]] }
-
-      it 'coerces elements in the nested set' do
-        expect(subject.call([%w[10 20]])).to eq([Set[10, 20]])
-        expect(subject.call([['10'], ['20']])).to eq([Set[10], Set[20]])
-      end
-    end
-  end
-end

data/spec/grape/validations/types/primitive_coercer_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::Types::PrimitiveCoercer do
-  subject { described_class.new(type, strict) }
-
-  let(:strict) { false }
-
-  describe '#call' do
-    context 'BigDecimal' do
-      let(:type) { BigDecimal }
-
-      it 'coerces to BigDecimal' do
-        expect(subject.call(5)).to eq(BigDecimal('5'))
-      end
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-    end
-
-    context 'Boolean' do
-      let(:type) { Grape::API::Boolean }
-
-      [true, 'true', 1].each do |val|
-        it "coerces '#{val}' to true" do
-          expect(subject.call(val)).to be(true)
-        end
-      end
-
-      [false, 'false', 0].each do |val|
-        it "coerces '#{val}' to false" do
-          expect(subject.call(val)).to be(false)
-        end
-      end
-
-      it 'returns an error when the given value cannot be coerced' do
-        expect(subject.call(123)).to be_instance_of(Grape::Validations::Types::InvalidValue)
-      end
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-    end
-
-    context 'DateTime' do
-      let(:type) { DateTime }
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-    end
-
-    context 'Float' do
-      let(:type) { Float }
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-    end
-
-    context 'Integer' do
-      let(:type) { Integer }
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-
-      it 'accepts non-nil value' do
-        expect(subject.call(42)).to be_a(Integer)
-      end
-    end
-
-    context 'Numeric' do
-      let(:type) { Numeric }
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-
-      it 'accepts a non-nil value' do
-        expect(subject.call(42)).to be_a(Numeric) # in fact Integer
-      end
-    end
-
-    context 'Time' do
-      let(:type) { Time }
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-    end
-
-    context 'String' do
-      let(:type) { String }
-
-      it 'coerces to String' do
-        expect(subject.call(10)).to eq('10')
-      end
-
-      it 'does not coerce an empty string to nil' do
-        expect(subject.call('')).to eq('')
-      end
-    end
-
-    context 'Symbol' do
-      let(:type) { Symbol }
-
-      it 'coerces an empty string to nil' do
-        expect(subject.call('')).to be_nil
-      end
-    end
-
-    context 'a type unknown in Dry-types' do
-      let(:type) { Complex }
-
-      it 'raises error on init' do
-        expect(DryTypes::Params.constants).not_to include(type.name.to_sym)
-        expect { subject }.to raise_error(/type Complex should support coercion/)
-      end
-    end
-
-    context 'the strict mode' do
-      let(:strict) { true }
-
-      context 'Boolean' do
-        let(:type) { Grape::API::Boolean }
-
-        it 'returns an error when the given value is not Boolean' do
-          expect(subject.call(1)).to be_instance_of(Grape::Validations::Types::InvalidValue)
-        end
-
-        it 'returns a value as it is when the given value is Boolean' do
-          expect(subject.call(true)).to be(true)
-        end
-      end
-
-      context 'BigDecimal' do
-        let(:type) { BigDecimal }
-
-        it 'returns an error when the given value is not BigDecimal' do
-          expect(subject.call(1)).to be_instance_of(Grape::Validations::Types::InvalidValue)
-        end
-
-        it 'returns a value as it is when the given value is BigDecimal' do
-          expect(subject.call(BigDecimal('0'))).to eq(BigDecimal('0'))
-        end
-      end
-    end
-  end
-end

data/spec/grape/validations/types/set_coercer_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::Types::SetCoercer do
-  subject { described_class.new(type) }
-
-  describe '#call' do
-    context 'a set of primitives' do
-      let(:type) { Set[String] }
-
-      it 'coerces elements to the set' do
-        expect(subject.call([10, 20])).to eq(Set['10', '20'])
-      end
-    end
-
-    context 'a set of sets' do
-      let(:type) { Set[Set[Integer]] }
-
-      it 'coerces elements in the nested set' do
-        expect(subject.call([%w[10 20]])).to eq(Set[Set[10, 20]])
-        expect(subject.call([['10'], ['20']])).to eq(Set[Set[10], Set[20]])
-      end
-    end
-
-    context 'a set of sets of arrays' do
-      let(:type) { Set[Set[Array[Integer]]] }
-
-      it 'coerces elements in the nested set' do
-        expect(subject.call([[['10'], ['20']]])).to eq(Set[Set[Array[10], Array[20]]])
-      end
-    end
-  end
-end

data/spec/grape/validations/types_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::Types do
-  module TypesSpec
-    class FooType
-      def self.parse(_); end
-    end
-
-    class BarType
-      def self.parse; end
-    end
-  end
-
-  describe '::primitive?' do
-    [
-      Integer, Float, Numeric, BigDecimal,
-      Grape::API::Boolean, String, Symbol,
-      Date, DateTime, Time
-    ].each do |type|
-      it "recognizes #{type} as a primitive" do
-        expect(described_class).to be_primitive(type)
-      end
-    end
-
-    it 'identifies unknown types' do
-      expect(described_class).not_to be_primitive(Object)
-      expect(described_class).not_to be_primitive(TypesSpec::FooType)
-    end
-  end
-
-  describe '::structure?' do
-    [
-      Hash, Array, Set
-    ].each do |type|
-      it "recognizes #{type} as a structure" do
-        expect(described_class).to be_structure(type)
-      end
-    end
-  end
-
-  describe '::special?' do
-    [
-      JSON, Array[JSON], File, Rack::Multipart::UploadedFile
-    ].each do |type|
-      it "provides special handling for #{type.inspect}" do
-        expect(described_class).to be_special(type)
-      end
-    end
-  end
-
-  describe 'special types' do
-    subject { described_class::SPECIAL[type] }
-
-    context 'when JSON' do
-      let(:type) { JSON }
-
-      it { is_expected.to eq(Grape::Validations::Types::Json) }
-    end
-
-    context 'when Array[JSON]' do
-      let(:type) { Array[JSON] }
-
-      it { is_expected.to eq(Grape::Validations::Types::JsonArray) }
-    end
-
-    context 'when File' do
-      let(:type) { File }
-
-      it { is_expected.to eq(Grape::Validations::Types::File) }
-    end
-
-    context 'when Rack::Multipart::UploadedFile' do
-      let(:type) { Rack::Multipart::UploadedFile }
-
-      it { is_expected.to eq(Grape::Validations::Types::File) }
-    end
-  end
-
-  describe '::custom?' do
-    it 'returns false if the type does not respond to :parse' do
-      expect(described_class).not_to be_custom(Object)
-    end
-
-    it 'returns true if the type responds to :parse with one argument' do
-      expect(described_class).to be_custom(TypesSpec::FooType)
-    end
-
-    it 'returns false if the type\'s #parse method takes other than one argument' do
-      expect(described_class).not_to be_custom(TypesSpec::BarType)
-    end
-  end
-
-  describe '::build_coercer' do
-    it 'has internal cache variables' do
-      expect(described_class.instance_variable_get(:@__cache)).to be_a(Hash)
-      expect(described_class.instance_variable_get(:@__cache_write_lock)).to be_a(Mutex)
-    end
-
-    it 'caches the result of the build_coercer method' do
-      original_cache = described_class.instance_variable_get(:@__cache)
-      described_class.instance_variable_set(:@__cache, {})
-
-      a_coercer = described_class.build_coercer(Array[String])
-      b_coercer = described_class.build_coercer(Array[String])
-
-      expect(a_coercer.object_id).to eq(b_coercer.object_id)
-
-      described_class.instance_variable_set(:@__cache, original_cache)
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::Validators::AllOrNoneOfValidator do
-  let_it_be(:app) do
-    Class.new(Grape::API) do
-      rescue_from Grape::Exceptions::ValidationErrors do |e|
-        error!(e.errors.transform_keys! { |key| key.join(',') }, 400)
-      end
-
-      params do
-        optional :beer, :wine, type: Grape::API::Boolean
-        all_or_none_of :beer, :wine
-      end
-      post do
-      end
-
-      params do
-        optional :beer, :wine, :other, type: Grape::API::Boolean
-        all_or_none_of :beer, :wine
-      end
-      post 'mixed-params' do
-      end
-
-      params do
-        optional :beer, :wine, type: Grape::API::Boolean
-        all_or_none_of :beer, :wine, message: 'choose all or none'
-      end
-      post '/custom-message' do
-      end
-
-      params do
-        requires :item, type: Hash do
-          optional :beer, :wine, type: Grape::API::Boolean
-          all_or_none_of :beer, :wine
-        end
-      end
-      post '/nested-hash' do
-      end
-
-      params do
-        requires :items, type: Array do
-          optional :beer, :wine, type: Grape::API::Boolean
-          all_or_none_of :beer, :wine
-        end
-      end
-      post '/nested-array' do
-      end
-
-      params do
-        requires :items, type: Array do
-          requires :nested_items, type: Array do
-            optional :beer, :wine, type: Grape::API::Boolean
-            all_or_none_of :beer, :wine
-          end
-        end
-      end
-      post '/deeply-nested-array' do
-      end
-    end
-  end
-
-  describe '#validate!' do
-    subject(:validate) { post path, params }
-
-    context 'when all restricted params are present' do
-      let(:path) { '/' }
-      let(:params) { { beer: true, wine: true } }
-
-      it 'does not return a validation error' do
-        validate
-        expect(last_response.status).to eq 201
-      end
-
-      context 'mixed with other params' do
-        let(:path) { '/mixed-params' }
-        let(:params) { { beer: true, wine: true, other: true } }
-
-        it 'does not return a validation error' do
-          validate
-          expect(last_response.status).to eq 201
-        end
-      end
-    end
-
-    context 'when a subset of restricted params are present' do
-      let(:path) { '/' }
-      let(:params) { { beer: true } }
-
-      it 'returns a validation error' do
-        validate
-        expect(last_response.status).to eq 400
-        expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine' => ['provide all or none of parameters']
-        )
-      end
-    end
-
-    context 'when custom message is specified' do
-      let(:path) { '/custom-message' }
-      let(:params) { { beer: true } }
-
-      it 'returns a validation error' do
-        validate
-        expect(last_response.status).to eq 400
-        expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine' => ['choose all or none']
-        )
-      end
-    end
-
-    context 'when no restricted params are present' do
-      let(:path) { '/' }
-      let(:params) { { somethingelse: true } }
-
-      it 'does not return a validation error' do
-        validate
-        expect(last_response.status).to eq 201
-      end
-    end
-
-    context 'when restricted params are nested inside required hash' do
-      let(:path) { '/nested-hash' }
-      let(:params) { { item: { beer: true } } }
-
-      it 'returns a validation error with full names of the params' do
-        validate
-        expect(last_response.status).to eq 400
-        expect(JSON.parse(last_response.body)).to eq(
-          'item[beer],item[wine]' => ['provide all or none of parameters']
-        )
-      end
-    end
-
-    context 'when mutually exclusive params are nested inside array' do
-      let(:path) { '/nested-array' }
-      let(:params) { { items: [{ beer: true, wine: true }, { wine: true }] } }
-
-      it 'returns a validation error with full names of the params' do
-        validate
-        expect(last_response.status).to eq 400
-        expect(JSON.parse(last_response.body)).to eq(
-          'items[1][beer],items[1][wine]' => ['provide all or none of parameters']
-        )
-      end
-    end
-
-    context 'when mutually exclusive params are deeply nested' do
-      let(:path) { '/deeply-nested-array' }
-      let(:params) { { items: [{ nested_items: [{ beer: true }] }] } }
-
-      it 'returns a validation error with full names of the params' do
-        validate
-        expect(last_response.status).to eq 400
-        expect(JSON.parse(last_response.body)).to eq(
-          'items[0][nested_items][0][beer],items[0][nested_items][0][wine]' => [
-            'provide all or none of parameters'
-          ]
-        )
-      end
-    end
-  end
-end