grape-swagger 1.6.0 → 2.0.0

data/spec/issues/776_multiple_presents_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe '#776 multiple presents spec' do
-  include_context "#{MODEL_PARSER} swagger example"
-
-  let(:app) do
-    Class.new(Grape::API) do
-      namespace :issue_776 do
-        desc 'Get multiple presents',
-             success: [
-               { model: Entities::EnumValues, as: :gender },
-               { model: Entities::Something, as: :somethings, is_array: true, required: true }
-             ]
-
-        get do
-          present :gender, { number: 1, gender: 'Male' }, with: Entities::EnumValues
-          present :somethings, [
-            { id: 1, text: 'element_1', links: %w[link1 link2] },
-            { id: 2, text: 'element_2', links: %w[link1 link2] }
-          ], with: Entities::Something, is_array: true
-        end
-      end
-
-      add_swagger_documentation format: :json
-    end
-  end
-
-  subject do
-    get '/swagger_doc'
-    JSON.parse(last_response.body)
-  end
-
-  let(:definitions) { subject['definitions'] }
-  let(:schema) { subject['paths']['/issue_776']['get']['responses']['200']['schema'] }
-
-  specify { expect(definitions.keys).to include 'EnumValues', 'Something' }
-
-  specify do
-    expect(schema).to eql({
-      'properties' => {
-        'somethings' => {
-          'items' => {
-            '$ref' => '#/definitions/Something'
-          },
-          'type' => 'array'
-        },
-        'gender' => {
-          '$ref' => '#/definitions/EnumValues'
-        }
-      },
-      'type' => 'object',
-      'required' => [
-        'somethings'
-      ]
-    })
-  end
-end

data/spec/issues/784_extensions_on_params_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe '#532 allow custom format' do
-  let(:app) do
-    Class.new(Grape::API) do
-      namespace :issue_784 do
-        params do
-          requires :logs, type: String, documentation: { format: 'log', x: { name: 'Log' } }
-          optional :phone_number, type: Integer, documentation: { format: 'phone_number', x: { name: 'PhoneNumber' } }
-        end
-
-        post do
-          present params
-        end
-      end
-
-      add_swagger_documentation format: :json
-    end
-  end
-
-  subject do
-    get '/swagger_doc'
-    JSON.parse(last_response.body)
-  end
-
-  let(:parameters) { subject['paths']['/issue_784']['post']['parameters'] }
-
-  specify do
-    expect(parameters).to eql(
-      [
-        { 'in' => 'formData', 'name' => 'logs', 'type' => 'string', 'format' => 'log', 'required' => true, 'x-name' => 'Log' },
-        { 'in' => 'formData', 'name' => 'phone_number', 'type' => 'integer', 'format' => 'phone_number', 'required' => false, 'x-name' => 'PhoneNumber' }
-      ]
-    )
-  end
-end

data/spec/issues/809_utf8_routes_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe '#605 root route documentation' do
-  let(:app) do
-    Class.new(Grape::API) do
-      resource :grunnbeløp do
-        desc 'returnerer grunnbeløp'
-        get do
-          { message: 'hello world' }
-        end
-      end
-
-      resource :εσόδων do
-        desc 'εσόδων'
-        get do
-          { message: 'hello world' }
-        end
-      end
-
-      resource :数 do
-        desc '数'
-        get do
-          { message: 'hello world' }
-        end
-      end
-
-      resource :amount do
-        desc 'returns amount'
-        get do
-          { message: 'hello world' }
-        end
-      end
-
-      resource :👍 do
-        desc 'returns 👍'
-        get do
-          { message: 'hello world' }
-        end
-      end
-
-      add_swagger_documentation
-    end
-  end
-
-  subject do
-    get '/swagger_doc'
-    JSON.parse(last_response.body)['paths']
-  end
-
-  specify do
-    expect(subject.keys).to match_array ['/grunnbeløp', '/amount', '/εσόδων', '/数']
-  end
-end

data/spec/issues/832_array_hash_float_decimal_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe '#832 array of objects with nested Float/BigDecimal fields' do
-  let(:app) do
-    Class.new(Grape::API) do
-      resource :issue_832 do
-        params do
-          requires :array_param, type: Array do
-            requires :float_param, type: Float
-            requires :big_decimal_param, type: BigDecimal
-            requires :object_param, type: Hash do
-              requires :float_param, type: Float
-              requires :big_decimal_param, type: BigDecimal
-              requires :object_param, type: Hash do
-                requires :float_param, type: Float
-                requires :big_decimal_param, type: BigDecimal
-                requires :array_param, type: Array do
-                  requires :integer_param, type: Integer
-                end
-              end
-            end
-          end
-        end
-        post do
-          {  message: 'hello world' }
-        end
-      end
-
-      add_swagger_documentation
-    end
-  end
-  let(:parameters) { subject['paths']['/issue_832']['post']['parameters'] }
-
-  subject do
-    get '/swagger_doc'
-    JSON.parse(last_response.body)
-  end
-
-  specify do
-    expect(parameters).to eql(
-      [
-        {
-          'in' => 'formData',
-          'name' => 'array_param[float_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'number',
-            'format' => 'float'
-          }
-        }, {
-          'in' => 'formData',
-          'name' => 'array_param[big_decimal_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'number',
-            'format' => 'double'
-          }
-        }, {
-          'in' => 'formData',
-          'name' => 'array_param[object_param][float_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'number',
-            'format' => 'float'
-          }
-        }, {
-          'in' => 'formData',
-          'name' => 'array_param[object_param][big_decimal_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'number',
-            'format' => 'double'
-          }
-        }, {
-          'in' => 'formData',
-          'name' => 'array_param[object_param][object_param][float_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'number',
-            'format' => 'float'
-          }
-        }, {
-          'in' => 'formData',
-          'name' => 'array_param[object_param][object_param][big_decimal_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'number',
-            'format' => 'double'
-          }
-        }, {
-          'in' => 'formData',
-          'name' => 'array_param[object_param][object_param][array_param][integer_param]',
-          'type' => 'array',
-          'required' => true,
-          'items' => {
-            'type' => 'integer',
-            'format' => 'int32'
-          }
-        }
-      ]
-    )
-  end
-end

data/spec/issues/847_route_param_options_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe '#847 route_param type is included in documentation' do
-  let(:app) do
-    Class.new(Grape::API) do
-      resource :accounts do
-        route_param :account_number, type: String do
-          resource :records do
-            route_param :id do
-              get do
-                { message: 'hello world' }
-              end
-            end
-          end
-        end
-      end
-
-      add_swagger_documentation
-    end
-  end
-  let(:parameters) { subject['paths']['/accounts/{account_number}/records/{id}']['get']['parameters'] }
-
-  subject do
-    get '/swagger_doc'
-    JSON.parse(last_response.body)
-  end
-
-  specify do
-    account_number_param = parameters.find { |param| param['name'] == 'account_number' }
-    expect(account_number_param['type']).to eq 'string'
-    id_param = parameters.find { |param| param['name'] == 'id' }
-    # Default is still integer
-    expect(id_param['type']).to eq 'integer'
-  end
-end

data/spec/lib/data_type_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::DocMethods::DataType do
-  subject { described_class.call(value) }
-
-  describe 'standards' do
-    ['Boolean', Date, Integer, String, Float].each do |type|
-      specify do
-        data_type = described_class.call(type: type)
-        expect(data_type).to eql type.to_s.downcase
-      end
-    end
-  end
-
-  describe 'Hash' do
-    let(:value) { { type: Hash } }
-
-    it { is_expected.to eq 'object' }
-  end
-
-  describe 'Multi types in a string' do
-    let(:value) { { type: '[String, Integer]' } }
-
-    it { is_expected.to eq 'string' }
-  end
-
-  describe 'Multi types in a string stating with A' do
-    let(:value) { { type: '[Apple, Orange]' } }
-
-    it { is_expected.to eq 'Apple' }
-  end
-
-  describe 'Multi types in array' do
-    let(:value) { { type: [String, Integer] } }
-
-    it { is_expected.to eq 'string' }
-  end
-
-  describe 'Types in array with entity_name' do
-    before do
-      stub_const 'MyEntity', Class.new
-      allow(MyEntity).to receive(:entity_name).and_return 'MyInteger'
-    end
-
-    let(:value) { { type: '[MyEntity]' } }
-
-    it { is_expected.to eq 'MyInteger' }
-  end
-
-  describe 'Types in array with inherited entity_name' do
-    before do
-      stub_const 'EntityBase', Class.new
-      allow(EntityBase).to receive(:entity_name).and_return 'MyInteger'
-      stub_const 'MyEntity', Class.new(EntityBase)
-    end
-
-    let(:value) { { type: '[MyEntity]' } }
-
-    it { is_expected.to eq 'MyInteger' }
-  end
-
-  describe 'Rack::Multipart::UploadedFile' do
-    let(:value) { { type: Rack::Multipart::UploadedFile } }
-
-    it { is_expected.to eq 'file' }
-  end
-
-  describe 'Grape::API::Boolean' do
-    let(:value) { { type: Grape::API::Boolean } }
-
-    it { is_expected.to eq 'boolean' }
-  end
-
-  describe 'BigDecimal' do
-    let(:value) { { type: BigDecimal } }
-
-    it { is_expected.to eq 'double' }
-  end
-
-  describe 'DateTime' do
-    let(:value) { { type: DateTime } }
-
-    it { is_expected.to eq 'dateTime' }
-  end
-
-  describe 'Numeric' do
-    let(:value) { { type: Numeric } }
-
-    it { is_expected.to eq 'long' }
-  end
-
-  describe 'Symbol' do
-    let(:value) { { type: Symbol } }
-
-    it { is_expected.to eq 'string' }
-  end
-
-  describe '[String]' do
-    let(:value) { { type: '[String]' } }
-
-    it { is_expected.to eq('string') }
-  end
-
-  describe '[Integer]' do
-    let(:value) { { type: '[Integer]' } }
-
-    it { is_expected.to eq('integer') }
-  end
-end

data/spec/lib/endpoint/params_parser_spec.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe GrapeSwagger::Endpoint::ParamsParser do
-  let(:settings) { {} }
-  let(:params) { [] }
-  let(:endpoint) { nil }
-
-  let(:parser) { described_class.new(params, settings, endpoint) }
-
-  describe '#parse_request_params' do
-    subject(:parse_request_params) { parser.parse_request_params }
-
-    context 'when param is of array type' do
-      let(:params) { [['param_1', { type: 'Array[String]' }]] }
-
-      it 'adds is_array option' do
-        expect(parse_request_params['param_1']).to eq(type: 'Array[String]', is_array: true)
-      end
-
-      context 'and array_use_braces setting set to true' do
-        let(:settings) { { array_use_braces: true } }
-
-        it 'adds braces to the param key' do
-          expect(parse_request_params.keys.first).to eq 'param_1[]'
-        end
-      end
-    end
-
-    context 'when param is of simple type' do
-      let(:params) { [['param_1', { type: 'String' }]] }
-
-      it 'does not change options' do
-        expect(parse_request_params['param_1']).to eq(type: 'String')
-      end
-
-      context 'and array_use_braces setting set to true' do
-        let(:settings) { { array_use_braces: true } }
-
-        it 'does not add braces to the param key' do
-          expect(parser.parse_request_params.keys.first).to eq 'param_1'
-        end
-      end
-    end
-
-    context 'when param is nested in a param of array type' do
-      let(:params) { [['param_1', { type: 'Array' }], ['param_1[param_2]', { type: 'String' }]] }
-
-      context 'and array_use_braces setting set to true' do
-        let(:settings) { { array_use_braces: true } }
-
-        it 'adds braces to the param key' do
-          expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
-        end
-      end
-    end
-
-    context 'when param is nested in a param of hash type' do
-      let(:params) { [param_1, param_2] }
-      let(:param_1) { ['param_1', { type: 'Hash' }] }
-      let(:param_2) { ['param_1[param_2]', { type: 'String' }] }
-
-      context 'and array_use_braces setting set to true' do
-        let(:settings) { { array_use_braces: true } }
-
-        context 'and param is of simple type' do
-          it 'does not add braces to the param key' do
-            expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
-          end
-        end
-
-        context 'and param is of array type' do
-          let(:param_2) { ['param_1[param_2]', { type: 'Array[String]' }] }
-
-          it 'adds braces to the param key' do
-            expect(parse_request_params.keys.last).to eq 'param_1[param_2][]'
-          end
-
-          context 'and `param_type` option is set to body' do
-            let(:param_2) do
-              ['param_1[param_2]', { type: 'Array[String]', documentation: { param_type: 'body' } }]
-            end
-
-            it 'does not add braces to the param key' do
-              expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
-            end
-          end
-
-          context 'and `in` option is set to body' do
-            let(:param_2) do
-              ['param_1[param_2]', { type: 'Array[String]', documentation: { in: 'body' } }]
-            end
-
-            it 'does not add braces to the param key' do
-              expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
-            end
-          end
-
-          context 'and hash `param_type` option is set to body' do
-            let(:param_1) { ['param_1', { type: 'Hash', documentation: { param_type: 'body' } }] }
-
-            it 'does not add braces to the param key' do
-              expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#param_type_is_array?' do
-    it 'returns true if the value passed represents an array' do
-      expect(parser.send(:param_type_is_array?, 'Array')).to be_truthy
-      expect(parser.send(:param_type_is_array?, '[String]')).to be_truthy
-      expect(parser.send(:param_type_is_array?, 'Array[Integer]')).to be_truthy
-    end
-
-    it 'returns false if the value passed does not represent an array' do
-      expect(parser.send(:param_type_is_array?, 'String')).to be_falsey
-      expect(parser.send(:param_type_is_array?, '[String, Integer]')).to be_falsey
-    end
-  end
-end

data/spec/lib/endpoint_spec.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Grape::Endpoint do
-  subject do
-    described_class.new(Grape::Util::InheritableSetting.new, path: '/', method: :get)
-  end
-
-  describe '.content_types_for' do
-    describe 'defined on target_class' do
-      let(:own_json) { 'text/own-json' }
-      let(:own_xml) { 'text/own-xml' }
-      let(:content_types) do
-        {
-          own_json: own_json,
-          own_xml: own_xml
-        }
-      end
-      let(:target_class) { OpenStruct.new(content_types: content_types) }
-
-      let(:object) { subject.content_types_for(target_class) }
-      specify do
-        expect(object).to eql [own_json, own_xml]
-      end
-    end
-
-    describe 'not defined' do
-      describe 'format given' do
-        let(:format) { :json }
-        let(:target_class) { OpenStruct.new(format: format) }
-        let(:object) { subject.content_types_for(target_class) }
-        specify do
-          expect(object).to eql ['application/json']
-        end
-
-        describe 'format not given' do
-          let(:target_class) { OpenStruct.new }
-          let(:object) { subject.content_types_for(target_class) }
-
-          specify do
-            expect(object).to eql %w[application/xml application/json text/plain]
-          end
-        end
-      end
-    end
-  end
-
-  describe 'parse_request_params' do
-    let(:subject) { GrapeSwagger::Endpoint::ParamsParser }
-    before do
-      subject.send(:parse_request_params, params, {}, nil)
-    end
-
-    context 'when params do not contain an array' do
-      let(:params) do
-        [
-          ['id', { required: true, type: 'String' }],
-          ['description', { required: false, type: 'String' }]
-        ]
-      end
-
-      let(:expected_params) do
-        [
-          ['id', { required: true, type: 'String' }],
-          ['description', { required: false, type: 'String' }]
-        ]
-      end
-
-      it 'parses params correctly' do
-        expect(params).to eq expected_params
-      end
-    end
-
-    context 'when params contain a simple array' do
-      let(:params) do
-        [
-          ['id', { required: true, type: 'String' }],
-          ['description', { required: false, type: 'String' }],
-          ['stuffs', { required: true, type: 'Array[String]' }]
-        ]
-      end
-
-      let(:expected_params) do
-        [
-          ['id', { required: true, type: 'String' }],
-          ['description', { required: false, type: 'String' }],
-          ['stuffs', { required: true, type: 'Array[String]', is_array: true }]
-        ]
-      end
-
-      it 'parses params correctly and adds is_array to the array' do
-        expect(params).to eq expected_params
-      end
-    end
-
-    context 'when params contain a complex array' do
-      let(:params) do
-        [
-          ['id', { required: true, type: 'String' }],
-          ['description', { required: false, type: 'String' }],
-          ['stuffs', { required: true, type: 'Array' }],
-          ['stuffs[id]', { required: true, type: 'String' }]
-        ]
-      end
-
-      let(:expected_params) do
-        [
-          ['id', { required: true, type: 'String' }],
-          ['description', { required: false, type: 'String' }],
-          ['stuffs', { required: true, type: 'Array', is_array: true }],
-          ['stuffs[id]', { required: true, type: 'String' }]
-        ]
-      end
-
-      it 'parses params correctly and adds is_array to the array and all elements' do
-        expect(params).to eq expected_params
-      end
-
-      context 'when array params are not contiguous with parent array' do
-        let(:params) do
-          [
-            ['id', { required: true, type: 'String' }],
-            ['description', { required: false, type: 'String' }],
-            ['stuffs', { required: true, type: 'Array' }],
-            ['stuffs[owners]', { required: true, type: 'Array' }],
-            ['stuffs[creators]', { required: true, type: 'Array' }],
-            ['stuffs[owners][id]', { required: true, type: 'String' }],
-            ['stuffs[creators][id]', { required: true, type: 'String' }],
-            ['stuffs_and_things', { required: true, type: 'String' }]
-          ]
-        end
-
-        let(:expected_params) do
-          [
-            ['id', { required: true, type: 'String' }],
-            ['description', { required: false, type: 'String' }],
-            ['stuffs', { required: true, type: 'Array', is_array: true }],
-            ['stuffs[owners]', { required: true, type: 'Array', is_array: true }],
-            ['stuffs[creators]', { required: true, type: 'Array', is_array: true }],
-            ['stuffs[owners][id]', { required: true, type: 'String' }],
-            ['stuffs[creators][id]', { required: true, type: 'String' }],
-            ['stuffs_and_things', { required: true, type: 'String' }]
-          ]
-        end
-
-        it 'parses params correctly and adds is_array to the array and all elements' do
-          expect(params).to eq expected_params
-        end
-      end
-    end
-  end
-end