grape 1.8.0 → 2.0.0

data/spec/grape/validations/attributes_doc_spec.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::ParamsScope::AttributesDoc do
-  shared_examples 'an optional doc attribute' do |attr|
-    it 'does not mention it' do
-      expected_opts.delete(attr)
-      validations.delete(attr)
-
-      expect(subject.first['nested[engine_age]']).not_to have_key(attr)
-    end
-  end
-
-  let(:api) { Class.new(Grape::API::Instance) }
-  let(:scope) do
-    params = nil
-    api_instance = api
-
-    # just to get nested params
-    Grape::Validations::ParamsScope.new(type: Hash, api: api) do
-      params = Grape::Validations::ParamsScope.new(element: 'nested',
-                                                   type: Hash,
-                                                   api: api_instance,
-                                                   parent: self)
-    end
-
-    params
-  end
-
-  let(:validations) do
-    {
-      presence: true,
-      desc: 'Age of...',
-      documentation: 'Age is...',
-      default: 1
-    }
-  end
-
-  let(:doc) { described_class.new(api, scope) }
-
-  describe '#extract_details' do
-    subject { doc.extract_details(validations) }
-
-    it 'cleans up doc attrs needed for documentation only' do
-      subject
-
-      expect(validations[:desc]).to be_nil
-      expect(validations[:documentation]).to be_nil
-    end
-
-    it 'does not clean up doc attrs mandatory for validators' do
-      subject
-
-      expect(validations[:presence]).not_to be_nil
-      expect(validations[:default]).not_to be_nil
-    end
-
-    it 'tells when attributes are required' do
-      subject
-
-      expect(doc.required).to be_truthy
-    end
-  end
-
-  describe '#document' do
-    subject do
-      doc.extract_details validations
-      doc.document attrs
-    end
-
-    let(:attrs) { %w[engine_age car_age] }
-    let(:valid_values) { [1, 3, 5, 8] }
-
-    let!(:expected_opts) do
-      {
-        required: true,
-        desc: validations[:desc],
-        documentation: validations[:documentation],
-        default: validations[:default],
-        type: 'Integer',
-        values: valid_values
-      }
-    end
-
-    before do
-      doc.type = Integer
-      doc.values = valid_values
-    end
-
-    context 'documentation is enabled' do
-      subject do
-        super()
-        api.namespace_stackable(:params)
-      end
-
-      it 'documents attributes' do
-        expect(subject.first).to eq('nested[engine_age]' => expected_opts,
-                                    'nested[car_age]' => expected_opts)
-      end
-
-      it_behaves_like 'an optional doc attribute', :default
-      it_behaves_like 'an optional doc attribute', :documentation
-      it_behaves_like 'an optional doc attribute', :desc
-      it_behaves_like 'an optional doc attribute', :type do
-        before { doc.type = nil }
-      end
-      it_behaves_like 'an optional doc attribute', :values do
-        before { doc.values = nil }
-      end
-
-      context 'false as a default value' do
-        before { validations[:default] = false }
-
-        it 'is still documented' do
-          doc = subject.first['nested[engine_age]']
-
-          expect(doc).to have_key(:default)
-          expect(doc[:default]).to be(false)
-        end
-      end
-
-      context 'nil as a default value' do
-        before { validations[:default] = nil }
-
-        it 'is still documented' do
-          doc = subject.first['nested[engine_age]']
-
-          expect(doc).to have_key(:default)
-          expect(doc[:default]).to be_nil
-        end
-      end
-
-      context 'the description key instead of desc' do
-        let!(:desc) { validations.delete(:desc) }
-
-        before { validations[:description] = desc }
-
-        it 'adds the given description' do
-          expect(subject.first['nested[engine_age]'][:desc]).to eq(desc)
-        end
-      end
-    end
-
-    context 'documentation is disabled' do
-      before { api.namespace_inheritable :do_not_document, true }
-
-      it 'does not document attributes' do
-        subject
-
-        expect(api.namespace_stackable(:params)).to eq([])
-      end
-    end
-  end
-end

data/spec/grape/validations/instance_behaivour_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-describe 'Validator with instance variables' do
-  let(:validator_type) do
-    Class.new(Grape::Validations::Validators::Base) do
-      def validate_param!(_attr_name, _params)
-        if instance_variable_defined?(:@instance_variable) && @instance_variable
-          raise Grape::Exceptions::Validation.new(params: ['params'],
-                                                  message: 'This should never happen')
-        end
-        @instance_variable = true
-      end
-    end
-  end
-  let(:app) do
-    Class.new(Grape::API) do
-      params do
-        optional :param_to_validate, instance_validator: true
-        optional :another_param_to_validate, instance_validator: true
-      end
-      get do
-        'noop'
-      end
-    end
-  end
-
-  before do
-    Grape::Validations.register_validator('instance_validator', validator_type)
-  end
-
-  after do
-    Grape::Validations.deregister_validator('instance_validator')
-  end
-
-  it 'passes validation every time' do
-    expect(validator_type).to receive(:new).exactly(4).times.and_call_original
-
-    2.times do
-      get '/', param_to_validate: 'value', another_param_to_validate: 'value'
-      expect(last_response.status).to eq 200
-    end
-  end
-end

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::MultipleAttributesIterator 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 third]) }
-
-    context 'when params is a hash' do
-      let(:params) do
-        { first: 'string', second: 'string' }
-      end
-
-      it 'yields the whole params hash without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_with_args(params)
-      end
-    end
-
-    context 'when params is an array' do
-      let(:params) do
-        [{ first: 'string1', second: 'string1' }, { first: 'string2', second: 'string2' }]
-      end
-
-      it 'yields each element of the array without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_successive_args(params[0], params[1])
-      end
-    end
-
-    context 'when params is empty optional placeholder' do
-      let(:params) { [Grape::DSL::Parameters::EmptyOptionalValue] }
-
-      it 'does not yield it' do
-        expect { |b| iterator.each(&b) }.to yield_successive_args
-      end
-    end
-  end
-end