gitlab-grape-swagger 1.5.0

data/spec/issues/847_route_param_options_spec.rb

@@ -0,0 +1,37 @@
+# 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/issues/873_wildcard_segments_path_parameters_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe '#873 detect wildcard segments as path parameters' do
+  let(:app) do
+    Class.new(Grape::API) do
+      resource :books do
+        get '*section/:title' do
+          { message: 'hello world' }
+        end
+      end
+
+      add_swagger_documentation
+    end
+  end
+  let(:parameters) { subject['paths']['/books/{section}/{title}']['get']['parameters'] }
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  specify do
+    section_param = parameters.find { |param| param['name'] == 'section' }
+    expect(section_param['in']).to eq 'path'
+  end
+end

data/spec/issues/878_optional_path_segments_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe '#878 handle optional path segments' do
+  let(:app) do
+    Class.new(Grape::API) do
+      resource :books do
+        get 'page(/one)(/:two)/three' do
+          { message: 'hello world' }
+        end
+      end
+
+      add_swagger_documentation
+    end
+  end
+  let(:parameters) { subject['paths']['/books/page/{two}/three']['get']['parameters'] }
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  specify do
+    section_param = parameters.find { |param| param['name'] == 'two' }
+    expect(section_param['in']).to eq 'path'
+    expect(subject['paths'].keys).to eq ['/books/page/three', '/books/page/{two}/three', '/books/page/one/three', '/books/page/one/{two}/three']
+  end
+end

data/spec/issues/881_handle_file_params_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe '#881 handle file params' do
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_881 do
+        params do
+          requires :upload, type: File
+        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(:consumes) { subject['paths']['/issue_881']['post']['consumes'] }
+  let(:parameters) { subject['paths']['/issue_881']['post']['parameters'] }
+
+  specify do
+    expect(consumes).to eql(
+        ["application/x-www-form-urlencoded", "multipart/form-data"]
+    )
+    expect(parameters).to eql(
+        [{"in"=>"formData", "name"=>"upload", "required"=>true, "type"=>"file"}]
+    )
+  end
+end

data/spec/issues/883_query_array_parameter_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe '#883 Group Params as Array' do
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_883 do
+        params do
+          requires :array_of_string, type: [String]
+          requires :array_of_integer, type: [Integer]
+        end
+        get '/get_primitive_array_parameters' do
+          'accepts array query parameters of primitive value types'
+        end
+
+        params do
+          requires :array_of, type: Array, documentation: { type: 'link', is_array: true }
+        end
+        get '/get_object_array_parameters' do
+          'does not accept array query parameters of object value types'
+        end
+      end
+      add_swagger_documentation
+    end
+  end
+
+  describe 'retrieves the documentation for typed group range parameters' do
+    subject do
+      get '/swagger_doc'
+      JSON.parse(last_response.body)
+    end
+
+    specify do
+      expect(subject['paths']['/issue_883/get_primitive_array_parameters']['get']['parameters']).to eql(
+        [
+          {'in'=>'query', 'name'=>'array_of_string', 'type'=>'array', 'items'=>{'type'=>'string'}, 'required'=>true},
+          {'in'=>'query', 'name'=>'array_of_integer', 'type'=>'array', 'items'=>{'type'=>'integer', 'format'=>'int32'}, 'required'=>true}
+        ]
+      )
+      expect(subject['paths']['/issue_883/get_object_array_parameters']['get']['parameters']).to eql(
+        [{'in'=>'formData', 'items'=>{'type'=>'string'}, 'name'=>'array_of', 'required'=>true, 'type'=>'array'}]
+      )
+    end
+  end
+end

data/spec/issues/884_dont_document_non_schema_examples_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec::Matchers.define_negated_matcher :exclude, :include
+
+describe '#884 dont document non-schema examples' do
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_884 do
+        params do
+          requires :id, type: Integer, documentation: { example: 123 }
+          optional :name, type: String, documentation: { example: 'Buddy Guy' }
+        end
+
+        post 'document_example' do
+          present params
+        end
+
+        desc 'do not document this' do
+          consumes ['application/x-www-form-urlencoded']
+        end
+        params do
+          requires :id, type: Integer, documentation: { example: 123 }
+          optional :name, type: String, documentation: { example: 'Buddy Guy' }
+        end
+
+        post 'dont_document_example' 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_document_example) { subject['definitions']['postIssue884DocumentExample']['properties'] }
+  let(:parameters_dont_document_example) { subject['paths']['/issue_884/dont_document_example']['post']['parameters'] }
+
+  specify do
+    expect(parameters_document_example.values).to all(include('example'))
+    expect(parameters_dont_document_example).to all(exclude('example'))
+  end
+end

data/spec/issues/887_prevent_duplicate_operation_ids_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe '#887 avoid duplciate operationIds' do
+  let(:app) do
+    Class.new(Grape::API) do
+      namespace :issue_887 do
+        get 'item/{id}/-/search' do
+          status 200
+        end
+
+        get 'item{id}/search' do
+          status 200
+        end
+
+        get 'item/{id}/search' do
+          status 200
+        end
+      end
+
+      add_swagger_documentation format: :json
+    end
+  end
+  let(:operation_ids) { subject['paths'].values.map{ |path| path['get']['operationId'] } }
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  specify do
+    expect(operation_ids).to eq ["getIssue887ItemIdSearch", "getIssue887ItemIdSearch2", "getIssue887ItemIdSearch3"]
+  end
+end

data/spec/lib/data_type_spec.rb

@@ -0,0 +1,111 @@
+# 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

@@ -0,0 +1,124 @@
+# 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

@@ -0,0 +1,153 @@
+# 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