grape-swagger 0.33.0 → 1.0.0

data/spec/lib/endpoint/params_parser_spec.rb

@@ -5,8 +5,9 @@ require 'spec_helper'
 describe GrapeSwagger::Endpoint::ParamsParser do
   let(:settings) { {} }
   let(:params) { [] }
+  let(:endpoint) { nil }
 
-  let(:parser) { described_class.new(params, settings) }
+  let(:parser) { described_class.new(params, settings, endpoint) }
 
   describe '#parse_request_params' do
     subject(:parse_request_params) { parser.parse_request_params }
@@ -46,39 +47,63 @@ describe GrapeSwagger::Endpoint::ParamsParser do
     context 'when param is nested in a param of array type' do
       let(:params) { [['param_1', { type: 'Array' }], ['param_1[param_2]', { type: 'String' }]] }
 
-      it 'skips root parameter' do
-        is_expected.not_to have_key 'param_1'
-      end
-
-      it 'adds is_array option to the nested param' do
-        expect(parse_request_params['param_1[param_2]']).to eq(type: '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[][param_2]'
+          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', { type: 'Hash' }], ['param_1[param_2]', { type: 'String' }]] }
-
-      it 'skips root parameter' do
-        is_expected.not_to have_key 'param_1'
-      end
-
-      it 'does not change options to the nested param' do
-        expect(parse_request_params['param_1[param_2]']).to eq(type: 'String')
-      end
+      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 } }
 
-        it 'does not add braces to the param key' do
-          expect(parse_request_params.keys.first).to eq 'param_1[param_2]'
+        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

data/spec/lib/endpoint_spec.rb

@@ -49,7 +49,7 @@ describe Grape::Endpoint do
   describe 'parse_request_params' do
     let(:subject) { GrapeSwagger::Endpoint::ParamsParser }
     before do
-      subject.send(:parse_request_params, params, {})
+      subject.send(:parse_request_params, params, {}, nil)
     end
 
     context 'when params do not contain an array' do
@@ -109,7 +109,7 @@ describe Grape::Endpoint 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', is_array: true }]
+          ['stuffs[id]', { required: true, type: 'String' }]
         ]
       end
 
@@ -138,8 +138,8 @@ describe Grape::Endpoint do
             ['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', is_array: true }],
-            ['stuffs[creators][id]', { required: true, type: 'String', 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

data/spec/lib/extensions_spec.rb

@@ -3,6 +3,16 @@
 require 'spec_helper'
 
 describe GrapeSwagger::DocMethods::Extensions do
+  context 'it should not break method introspection' do
+    describe '.method' do
+      describe 'method introspection' do
+        specify do
+          expect(described_class.method(described_class.methods.first)).to be_a(Method)
+        end
+      end
+    end
+  end
+
   describe '#find_definition' do
     subject { described_class }
 

data/spec/lib/format_data_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::FormatData do
+  let(:subject) { GrapeSwagger::DocMethods::FormatData }
+
+  [true, false].each do |array_use_braces|
+    context 'when param is nested in a param of array type' do
+      let(:braces) { array_use_braces ? '[]' : '' }
+      let(:params) do
+        [
+          { in: 'formData', name: "param1#{braces}", type: 'array', items: { type: 'string' } },
+          { in: 'formData', name: 'param1[param2]', type: 'string' }
+        ]
+      end
+
+      it 'skips root parameter' do
+        expect(subject.to_format(params).first).not_to have_key "param1#{braces}"
+      end
+
+      it 'Move array type to param2' do
+        expect(subject.to_format(params).first).to include(name: "param1#{braces}[param2]", type: 'array')
+      end
+    end
+  end
+
+  context 'when param is nested in a param of hash type' do
+    let(:params) { [{ in: 'formData', type: 'object', name: 'param1' }, { in: 'formData', name: 'param1[param2]', type: 'string' }] }
+
+    it 'skips root parameter' do
+      expect(subject.to_format(params).first).not_to have_key 'param1'
+    end
+
+    it 'Move array type to param2' do
+      expect(subject.to_format(params).first).to include(name: 'param1[param2]', type: 'string')
+    end
+  end
+
+  context 'when params contain a complex array' do
+    let(:params) do
+      [
+        { name: 'id', required: true, type: 'string' },
+        { name: 'description', required: false, type: 'string' },
+        { name: 'stuffs', required: true, type: 'array' },
+        { name: 'stuffs[id]', required: true, type: 'string' }
+      ]
+    end
+
+    let(:expected_params) do
+      [
+        { name: 'id', required: true, type: 'string' },
+        { name: 'description', required: false, type: 'string' },
+        { name: 'stuffs[id]', required: true, type: 'array', items: { type: 'string' } }
+      ]
+    end
+
+    it 'parses params correctly and adds array type all concerned elements' do
+      expect(subject.to_format(params)).to eq expected_params
+    end
+
+    context 'when array params are not contiguous with parent array' do
+      let(:params) do
+        [
+          { name: 'id', required: true, type: 'string' },
+          { name: 'description', required: false, type: 'string' },
+          { name: 'stuffs', required: true, type: 'array' },
+          { name: 'stuffs[owners]', required: true, type: 'array' },
+          { name: 'stuffs[creators]', required: true, type: 'array' },
+          { name: 'stuffs[owners][id]', required: true, type: 'string' },
+          { name: 'stuffs[creators][id]', required: true, type: 'string' },
+          { name: 'stuffs_and_things', required: true, type: 'string' }
+        ]
+      end
+
+      let(:expected_params) do
+        [
+          { name: 'id', required: true, type: 'string' },
+          { name: 'description', required: false, type: 'string' },
+          { name: 'stuffs[owners][id]', required: true, type: 'array', items: { type: 'string' } },
+          { name: 'stuffs[creators][id]', required: true, type: 'array', items: { type: 'string' } },
+          { name: 'stuffs_and_things', required: true, type: 'string' }
+        ]
+      end
+
+      it 'parses params correctly and adds array type all concerned elements' do
+        expect(subject.to_format(params)).to eq expected_params
+      end
+    end
+  end
+end

data/spec/lib/move_params_spec.rb

@@ -40,13 +40,13 @@ describe GrapeSwagger::DocMethods::MoveParams do
     describe 'movable params' do
       specify 'allowed verbs' do
         allowed_verbs.each do |verb|
-          expect(subject.can_be_moved?(movable_params, verb)).to be true
+          expect(subject.can_be_moved?(verb, movable_params)).to be true
         end
       end
 
       specify 'not allowed verbs' do
         not_allowed_verbs.each do |verb|
-          expect(subject.can_be_moved?(movable_params, verb)).to be false
+          expect(subject.can_be_moved?(verb, movable_params)).to be false
         end
       end
     end
@@ -54,13 +54,13 @@ describe GrapeSwagger::DocMethods::MoveParams do
     describe 'not movable params' do
       specify 'allowed verbs' do
         allowed_verbs.each do |verb|
-          expect(subject.can_be_moved?(not_movable_params, verb)).to be false
+          expect(subject.can_be_moved?(verb, not_movable_params)).to be false
         end
       end
 
       specify 'not allowed verbs' do
         not_allowed_verbs.each do |verb|
-          expect(subject.can_be_moved?(not_movable_params, verb)).to be false
+          expect(subject.can_be_moved?(verb, not_movable_params)).to be false
         end
       end
     end
@@ -326,268 +326,6 @@ describe GrapeSwagger::DocMethods::MoveParams do
       end
     end
 
-    describe 'prepare_nested_types' do
-      before :each do
-        subject.send(:prepare_nested_types, params)
-      end
-
-      let(:params) do
-        [
-          {
-            in: 'body',
-            name: 'address[street_lines]',
-            description: 'street lines',
-            type: 'array',
-            items: {
-              type: 'string'
-            },
-            required: true
-          }
-        ]
-      end
-
-      context 'when params contains nothing with :items key' do
-        let(:params) do
-          [
-            {
-              in: 'body',
-              name: 'phone_number',
-              description: 'phone number',
-              type: 'string',
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_params) do
-          [
-            {
-              in: 'body',
-              name: 'phone_number',
-              description: 'phone number',
-              type: 'string',
-              required: true
-            }
-          ]
-        end
-
-        it 'does nothing' do
-          expect(params).to eq expected_params
-        end
-      end
-
-      context 'when params contains :items key with array type' do
-        let(:params) do
-          [
-            {
-              in: 'body',
-              name: 'address_street_lines',
-              description: 'street lines',
-              type: 'array',
-              items: {
-                type: 'array'
-              },
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_params) do
-          [
-            {
-              in: 'body',
-              name: 'address_street_lines',
-              description: 'street lines',
-              type: 'string',
-              required: true
-            }
-          ]
-        end
-
-        it 'sets type to string and removes :items' do
-          expect(params).to eq expected_params
-        end
-      end
-
-      context 'when params contains :items key with $ref' do
-        let(:params) do
-          [
-            {
-              in: 'body',
-              name: 'address_street_lines',
-              description: 'street lines',
-              type: 'array',
-              items: {
-                '$ref' => '#/definitions/StreetLine'
-              },
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_params) do
-          [
-            {
-              in: 'body',
-              name: 'address_street_lines',
-              description: 'street lines',
-              type: 'object',
-              items: {
-                '$ref' => '#/definitions/StreetLine'
-              },
-              required: true
-            }
-          ]
-        end
-
-        it 'sets type to object and does not remove :items' do
-          expect(params).to eq expected_params
-        end
-      end
-
-      context 'when params contains :items without $ref or array type' do
-        let(:params) do
-          [
-            {
-              in: 'body',
-              name: 'address_street_lines',
-              description: 'street lines',
-              type: 'array',
-              items: {
-                type: 'string'
-              },
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_params) do
-          [
-            {
-              in: 'body',
-              name: 'address_street_lines',
-              description: 'street lines',
-              type: 'string',
-              required: true
-            }
-          ]
-        end
-
-        it 'sets type to :items :type and removes :items' do
-          expect(params).to eq expected_params
-        end
-      end
-
-      context 'when params contains :items key with :format' do
-        let(:params) do
-          [
-            {
-              in: 'body',
-              name: 'street_number',
-              description: 'street number',
-              type: 'array',
-              items: {
-                type: 'integer',
-                format: 'int32'
-              },
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_params) do
-          [
-            {
-              in: 'body',
-              name: 'street_number',
-              description: 'street number',
-              type: 'integer',
-              format: 'int32',
-              required: true
-            }
-          ]
-        end
-
-        it 'sets format and removes :items' do
-          expect(params).to eq expected_params
-        end
-      end
-    end
-
-    describe 'recursive_call' do
-      before :each do
-        subject.send(:recursive_call, properties, 'test', nested_params)
-      end
-
-      let(:properties) { {} }
-
-      context 'when nested params is an array' do
-        let(:nested_params) do
-          [
-            {
-              in: 'body',
-              name: 'aliases',
-              description: 'The aliases of test.',
-              type: 'array',
-              items: { type: 'string' },
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_properties) do
-          {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                aliases: {
-                  type: 'string',
-                  description: 'The aliases of test.'
-                }
-              },
-              required: [:aliases]
-            }
-          }
-        end
-
-        it 'adds property as symbol with array type and items' do
-          expect(properties[:test]).to eq expected_properties
-        end
-      end
-
-      context 'when nested params is not an array' do
-        let(:nested_params) do
-          [
-            {
-              in: 'body',
-              name: 'id',
-              description: 'The unique ID of test.',
-              type: 'string',
-              required: true
-            }
-          ]
-        end
-
-        let(:expected_properties) do
-          {
-            type: 'object',
-            required: [:id],
-            properties: {
-              id: {
-                type: 'string',
-                description: 'The unique ID of test.'
-              }
-            }
-          }
-        end
-
-        it 'adds property as symbol with object type' do
-          expect(properties[:test]).to eq expected_properties
-        end
-      end
-    end
-
     describe 'add_properties_to_definition' do
       before :each do
         subject.send(:add_properties_to_definition, definition, properties, [])

data/spec/lib/optional_object_spec.rb

@@ -39,7 +39,6 @@ describe GrapeSwagger::DocMethods::OptionalObject do
       let(:options) do
         { host: proc { |request| request.host =~ /^example/ ? '/api-example' : '/api' } }
       end
-      # rubocop:enable RegexpMatch
       specify do
         expect(subject.build(key, options, request)).to eql '/api-example'
       end

data/spec/spec_helper.rb

@@ -19,7 +19,7 @@ MODEL_PARSER = ENV.key?('MODEL_PARSER') ? ENV['MODEL_PARSER'].to_s.downcase.sub(
 require 'grape'
 require 'grape-swagger'
 
-Dir[File.join(Dir.getwd, 'spec/support/*.rb')].each { |f| require f }
+Dir[File.join(Dir.getwd, 'spec/support/*.rb')].sort.each { |f| require f }
 require "grape-swagger/#{MODEL_PARSER}" if MODEL_PARSER != 'mock'
 require File.join(Dir.getwd, "spec/support/model_parsers/#{MODEL_PARSER}_parser.rb")
 

data/spec/support/model_parsers/entity_parser.rb

@@ -116,7 +116,7 @@ RSpec.shared_context 'entity swagger example' do
         expose :prop_time,      documentation: { type: Time, desc: 'prop_time description' }
         expose :prop_password,  documentation: { type: 'password', desc: 'prop_password description' }
         expose :prop_email,     documentation: { type: 'email', desc: 'prop_email description' }
-        expose :prop_boolean,   documentation: { type: Virtus::Attribute::Boolean, desc: 'prop_boolean description' }
+        expose :prop_boolean,   documentation: { type: Grape::API::Boolean, desc: 'prop_boolean description' }
         expose :prop_file,      documentation: { type: File, desc: 'prop_file description' }
         expose :prop_json,      documentation: { type: JSON, desc: 'prop_json description' }
       end

data/spec/support/model_parsers/representable_parser.rb

@@ -186,7 +186,7 @@ RSpec.shared_context 'representable swagger example' do
         property :prop_time,      documentation: { type: Time, desc: 'prop_time description' }
         property :prop_password,  documentation: { type: 'password', desc: 'prop_password description' }
         property :prop_email,     documentation: { type: 'email', desc: 'prop_email description' }
-        property :prop_boolean,   documentation: { type: Virtus::Attribute::Boolean, desc: 'prop_boolean description' }
+        property :prop_boolean,   documentation: { type: Grape::API::Boolean, desc: 'prop_boolean description' }
         property :prop_file,      documentation: { type: File, desc: 'prop_file description' }
         property :prop_json,      documentation: { type: JSON, desc: 'prop_json description' }
       end

data/spec/swagger_v2/api_swagger_v2_hash_and_array_spec.rb

@@ -10,7 +10,9 @@ describe 'document hash and array' do
       class TestApi < Grape::API
         format :json
 
-        documentation = ::Entities::DocumentedHashAndArrayModel.documentation if ::Entities::DocumentedHashAndArrayModel.respond_to?(:documentation)
+        if ::Entities::DocumentedHashAndArrayModel.respond_to?(:documentation)
+          documentation = ::Entities::DocumentedHashAndArrayModel.documentation
+        end
 
         desc 'This returns something'
         namespace :arbitrary do

data/spec/swagger_v2/api_swagger_v2_hide_param_spec.rb

@@ -7,12 +7,19 @@ describe 'hidden flag enables a single endpoint parameter to be excluded from th
   before :all do
     module TheApi
       class HideParamsApi < Grape::API
+        helpers do
+          def resource_owner
+            '123'
+          end
+        end
+
         namespace :flat_params_endpoint do
           desc 'This is a endpoint with a flat parameter hierarchy'
           params do
             requires :name, type: String, documentation: { desc: 'name' }
             optional :favourite_color, type: String, documentation: { desc: 'I should not be anywhere', hidden: true }
-            optional :proc_param, type: String, documentation: { desc: 'I should not be anywhere', hidden: -> { true } }
+            optional :proc_param, type: String, documentation: { desc: 'I should not be anywhere', hidden: proc { true } }
+            optional :proc_with_token, type: String, documentation: { desc: 'I may be somewhere', hidden: proc { |token_owner = nil| token_owner.nil? } }
           end
 
           post do
@@ -50,7 +57,7 @@ describe 'hidden flag enables a single endpoint parameter to be excluded from th
           end
         end
 
-        add_swagger_documentation
+        add_swagger_documentation token_owner: 'resource_owner'
       end
     end
   end
@@ -63,9 +70,13 @@ describe 'hidden flag enables a single endpoint parameter to be excluded from th
       JSON.parse(last_response.body)
     end
 
-    specify do
+    it 'ignores parameters that are explicitly hidden' do
       expect(subject['paths']['/flat_params_endpoint']['post']['parameters'].map { |p| p['name'] }).not_to include('favourite_color', 'proc_param')
     end
+
+    it 'allows procs to consult the token_owner' do
+      expect(subject['paths']['/flat_params_endpoint']['post']['parameters'].map { |p| p['name'] }).to include('proc_with_token')
+    end
   end
 
   describe 'nested parameter hierarchy' do