grape-swagger 0.30.1 → 0.31.0

data/spec/lib/endpoint_spec.rb

@@ -7,19 +7,6 @@ describe Grape::Endpoint do
     described_class.new(Grape::Util::InheritableSetting.new, path: '/', method: :get)
   end
 
-  describe '#param_type_is_array?' do
-    it 'returns true if the value passed represents an array' do
-      expect(subject.send(:param_type_is_array?, 'Array')).to be_truthy
-      expect(subject.send(:param_type_is_array?, '[String]')).to be_truthy
-      expect(subject.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(subject.send(:param_type_is_array?, 'String')).to be_falsey
-      expect(subject.send(:param_type_is_array?, '[String, Integer]')).to be_falsey
-    end
-  end
-
   describe '.content_types_for' do
     describe 'defined on target_class' do
       let(:own_json) { 'text/own-json' }
@@ -58,4 +45,109 @@ describe Grape::Endpoint do
       end
     end
   end
+
+  describe 'parse_request_params' do
+    let(:subject) { GrapeSwagger::Endpoint::ParamsParser }
+    before do
+      subject.send(:parse_request_params, params, {})
+    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', is_array: true }]
+        ]
+      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', is_array: true }],
+            ['stuffs[creators][id]', { required: true, type: 'String', is_array: true }],
+            ['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

data/spec/lib/move_params_spec.rb

@@ -513,5 +513,180 @@ describe GrapeSwagger::DocMethods::MoveParams do
         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, [])
+      end
+
+      context 'when definition has items key' do
+        let(:definition) do
+          {
+            type: 'array',
+            items:  {
+              type: 'object',
+              properties: {
+                description: 'Test description'
+              }
+            }
+          }
+        end
+
+        let(:properties) do
+          {
+            strings: {
+              type: 'string',
+              description: 'string elements'
+            }
+          }
+        end
+
+        let(:expected_definition) do
+          {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                description: 'Test description',
+                strings: {
+                  type: 'string',
+                  description: 'string elements'
+                }
+              }
+            }
+          }
+        end
+
+        it 'deep merges properties into definition item properties' do
+          expect(definition).to eq expected_definition
+        end
+      end
+
+      context 'when definition does not have items key' do
+        let(:definition) do
+          {
+            type: 'object',
+            properties: {
+              parent: {
+                type: 'object',
+                description: 'Parent to child'
+              }
+            }
+          }
+        end
+
+        let(:properties) do
+          {
+            parent: {
+              type: 'object',
+              properties: {
+                id: {
+                  type: 'string',
+                  description: 'Parent ID'
+                }
+              },
+              required: [:id]
+            }
+          }
+        end
+
+        let(:expected_definition) do
+          {
+            type: 'object',
+            properties: {
+              parent: {
+                type: 'object',
+                description: 'Parent to child',
+                properties: {
+                  id: {
+                    type: 'string',
+                    description: 'Parent ID'
+                  }
+                },
+                required: [:id]
+              }
+            }
+          }
+        end
+
+        it 'deep merges properties into definition properties' do
+          expect(definition).to eq expected_definition
+        end
+      end
+    end
   end
 end

data/spec/swagger_v2/params_array_spec.rb

@@ -5,193 +5,199 @@ require 'spec_helper'
 describe 'Group Params as Array' do
   include_context "#{MODEL_PARSER} swagger example"
 
-  def app
-    Class.new(Grape::API) do
-      format :json
-
-      params do
-        requires :required_group, type: Array do
-          requires :required_param_1
-          requires :required_param_2
+  [true, false].each do |array_use_braces|
+    context "when array_use_braces option is set to #{array_use_braces}" do
+      let(:braces) { array_use_braces ? '[]' : '' }
+
+      let(:app) do
+        Class.new(Grape::API) do
+          format :json
+
+          params do
+            requires :required_group, type: Array do
+              requires :required_param_1
+              requires :required_param_2
+            end
+          end
+          post '/groups' do
+            { 'declared_params' => declared(params) }
+          end
+
+          params do
+            requires :typed_group, type: Array do
+              requires :id, type: Integer, desc: 'integer given'
+              requires :name, type: String, desc: 'string given'
+              optional :email, type: String, desc: 'email given'
+              optional :others, type: Integer, values: [1, 2, 3]
+            end
+          end
+          post '/type_given' do
+            { 'declared_params' => declared(params) }
+          end
+
+          # as body parameters it would be interpreted a bit different,
+          # cause it could not be distinguished anymore, so this would be translated to one array,
+          # see also next example for the difference
+          params do
+            requires :array_of_string, type: Array[String], documentation: { param_type: 'body', desc: 'nested array of strings' }
+            requires :array_of_integer, type: Array[Integer], documentation: { param_type: 'body', desc: 'nested array of integers' }
+          end
+
+          post '/array_of_type' do
+            { 'declared_params' => declared(params) }
+          end
+
+          params do
+            requires :array_of_string, type: Array[String], documentation: { param_type: 'body', desc: 'array of strings' }
+            requires :integer_value, type: Integer, documentation: { param_type: 'body', desc: 'integer value' }
+          end
+
+          post '/object_and_array' do
+            { 'declared_params' => declared(params) }
+          end
+
+          params do
+            requires :array_of_string, type: Array[String]
+            requires :array_of_integer, type: Array[Integer]
+          end
+
+          post '/array_of_type_in_form' do
+            { 'declared_params' => declared(params) }
+          end
+
+          params do
+            requires :array_of_entities, type: Array[Entities::ApiError]
+          end
+
+          post '/array_of_entities' do
+            { 'declared_params' => declared(params) }
+          end
+
+          add_swagger_documentation array_use_braces: array_use_braces
         end
       end
-      post '/groups' do
-        { 'declared_params' => declared(params) }
-      end
 
-      params do
-        requires :typed_group, type: Array do
-          requires :id, type: Integer, desc: 'integer given'
-          requires :name, type: String, desc: 'string given'
-          optional :email, type: String, desc: 'email given'
-          optional :others, type: Integer, values: [1, 2, 3]
+      describe 'retrieves the documentation for grouped parameters' do
+        subject do
+          get '/swagger_doc/groups'
+          JSON.parse(last_response.body)
         end
-      end
-      post '/type_given' do
-        { 'declared_params' => declared(params) }
-      end
 
-      # as body parameters it would be interpreted a bit different,
-      # cause it could not be distinguished anymore, so this would be translated to one array,
-      # see also next example for the difference
-      params do
-        requires :array_of_string, type: Array[String], documentation: { param_type: 'body', desc: 'nested array of strings' }
-        requires :array_of_integer, type: Array[Integer], documentation: { param_type: 'body', desc: 'nested array of integers' }
-      end
-
-      post '/array_of_type' do
-        { 'declared_params' => declared(params) }
+        specify do
+          expect(subject['paths']['/groups']['post']['parameters']).to eql(
+            [
+              { 'in' => 'formData', 'name' => "required_group#{braces}[required_param_1]", 'required' => true, 'type' => 'array', 'items' => { 'type' => 'string' } },
+              { 'in' => 'formData', 'name' => "required_group#{braces}[required_param_2]", 'required' => true, 'type' => 'array', 'items' => { 'type' => 'string' } }
+            ]
+          )
+        end
       end
 
-      params do
-        requires :array_of_string, type: Array[String], documentation: { param_type: 'body', desc: 'array of strings' }
-        requires :integer_value, type: Integer, documentation: { param_type: 'body', desc: 'integer value' }
-      end
+      describe 'retrieves the documentation for typed group parameters' do
+        subject do
+          get '/swagger_doc/type_given'
+          JSON.parse(last_response.body)
+        end
 
-      post '/object_and_array' do
-        { 'declared_params' => declared(params) }
+        specify do
+          expect(subject['paths']['/type_given']['post']['parameters']).to eql(
+            [
+              { 'in' => 'formData', 'name' => "typed_group#{braces}[id]", 'description' => 'integer given', 'type' => 'array', 'items' => { 'type' => 'integer', 'format' => 'int32' }, 'required' => true },
+              { 'in' => 'formData', 'name' => "typed_group#{braces}[name]", 'description' => 'string given', 'type' => 'array', 'items' => { 'type' => 'string' }, 'required' => true },
+              { 'in' => 'formData', 'name' => "typed_group#{braces}[email]", 'description' => 'email given', 'type' => 'array', 'items' => { 'type' => 'string' }, 'required' => false },
+              { 'in' => 'formData', 'name' => "typed_group#{braces}[others]", 'type' => 'array', 'items' => { 'type' => 'integer', 'format' => 'int32', 'enum' => [1, 2, 3] }, 'required' => false }
+            ]
+          )
+        end
       end
 
-      params do
-        requires :array_of_string, type: Array[String]
-        requires :array_of_integer, type: Array[Integer]
-      end
+      describe 'retrieves the documentation for parameters that are arrays of primitive types' do
+        subject do
+          get '/swagger_doc/array_of_type'
+          JSON.parse(last_response.body)
+        end
 
-      post '/array_of_type_in_form' do
-        { 'declared_params' => declared(params) }
+        specify do
+          expect(subject['definitions']['postArrayOfType']['type']).to eql 'array'
+          expect(subject['definitions']['postArrayOfType']['items']).to eql(
+            'type' => 'object',
+            'properties' => {
+              'array_of_string' => {
+                'type' => 'string', 'description' => 'nested array of strings'
+              },
+              'array_of_integer' => {
+                'type' => 'integer', 'format' => 'int32', 'description' => 'nested array of integers'
+              }
+            },
+            'required' => %w[array_of_string array_of_integer]
+          )
+        end
       end
 
-      params do
-        requires :array_of_entities, type: Array[Entities::ApiError]
-      end
+      describe 'documentation for simple and array parameters' do
+        subject do
+          get '/swagger_doc/object_and_array'
+          JSON.parse(last_response.body)
+        end
 
-      post '/array_of_entities' do
-        { 'declared_params' => declared(params) }
+        specify do
+          expect(subject['definitions']['postObjectAndArray']['type']).to eql 'object'
+          expect(subject['definitions']['postObjectAndArray']['properties']).to eql(
+            'array_of_string' => {
+              'type' => 'array',
+              'description' => 'array of strings',
+              'items' => {
+                'type' => 'string'
+              }
+            },
+            'integer_value' => {
+              'type' => 'integer', 'format' => 'int32', 'description' => 'integer value'
+            }
+          )
+        end
       end
 
-      add_swagger_documentation
-    end
-  end
-
-  describe 'retrieves the documentation for grouped parameters' do
-    subject do
-      get '/swagger_doc/groups'
-      JSON.parse(last_response.body)
-    end
-
-    specify do
-      expect(subject['paths']['/groups']['post']['parameters']).to eql(
-        [
-          { 'in' => 'formData', 'name' => 'required_group[required_param_1]', 'required' => true, 'type' => 'array', 'items' => { 'type' => 'string' } },
-          { 'in' => 'formData', 'name' => 'required_group[required_param_2]', 'required' => true, 'type' => 'array', 'items' => { 'type' => 'string' } }
-        ]
-      )
-    end
-  end
-
-  describe 'retrieves the documentation for typed group parameters' do
-    subject do
-      get '/swagger_doc/type_given'
-      JSON.parse(last_response.body)
-    end
-
-    specify do
-      expect(subject['paths']['/type_given']['post']['parameters']).to eql(
-        [
-          { 'in' => 'formData', 'name' => 'typed_group[id]', 'description' => 'integer given', 'type' => 'array', 'items' => { 'type' => 'integer', 'format' => 'int32' }, 'required' => true },
-          { 'in' => 'formData', 'name' => 'typed_group[name]', 'description' => 'string given', 'type' => 'array', 'items' => { 'type' => 'string' }, 'required' => true },
-          { 'in' => 'formData', 'name' => 'typed_group[email]', 'description' => 'email given', 'type' => 'array', 'items' => { 'type' => 'string' }, 'required' => false },
-          { 'in' => 'formData', 'name' => 'typed_group[others]', 'type' => 'array', 'items' => { 'type' => 'integer', 'format' => 'int32', 'enum' => [1, 2, 3] }, 'required' => false }
-        ]
-      )
-    end
-  end
-
-  describe 'retrieves the documentation for parameters that are arrays of primitive types' do
-    subject do
-      get '/swagger_doc/array_of_type'
-      JSON.parse(last_response.body)
-    end
-
-    specify do
-      expect(subject['definitions']['postArrayOfType']['type']).to eql 'array'
-      expect(subject['definitions']['postArrayOfType']['items']).to eql(
-        'type' => 'object',
-        'properties' => {
-          'array_of_string' => {
-            'type' => 'string', 'description' => 'nested array of strings'
-          },
-          'array_of_integer' => {
-            'type' => 'integer', 'format' => 'int32', 'description' => 'nested array of integers'
-          }
-        },
-        'required' => %w[array_of_string array_of_integer]
-      )
-    end
-  end
-
-  describe 'documentation for simple and array parameters' do
-    subject do
-      get '/swagger_doc/object_and_array'
-      JSON.parse(last_response.body)
-    end
-
-    specify do
-      expect(subject['definitions']['postObjectAndArray']['type']).to eql 'object'
-      expect(subject['definitions']['postObjectAndArray']['properties']).to eql(
-        'array_of_string' => {
-          'type' => 'array',
-          'description' => 'array of strings',
-          'items' => {
-            'type' => 'string'
-          }
-        },
-        'integer_value' => {
-          'type' => 'integer', 'format' => 'int32', 'description' => 'integer value'
-        }
-      )
-    end
-  end
-
-  describe 'retrieves the documentation for typed group parameters' do
-    subject do
-      get '/swagger_doc/array_of_type_in_form'
-      JSON.parse(last_response.body)
-    end
+      describe 'retrieves the documentation for typed group parameters' do
+        subject do
+          get '/swagger_doc/array_of_type_in_form'
+          JSON.parse(last_response.body)
+        end
 
-    specify do
-      expect(subject['paths']['/array_of_type_in_form']['post']['parameters']).to eql(
-        [
-          { 'in' => 'formData', 'name' => 'array_of_string', 'type' => 'array', 'items' => { 'type' => 'string' }, 'required' => true },
-          { 'in' => 'formData', 'name' => 'array_of_integer', 'type' => 'array', 'items' => { 'type' => 'integer', 'format' => 'int32' }, 'required' => true }
-        ]
-      )
-    end
-  end
+        specify do
+          expect(subject['paths']['/array_of_type_in_form']['post']['parameters']).to eql(
+            [
+              { 'in' => 'formData', 'name' => "array_of_string#{braces}", 'type' => 'array', 'items' => { 'type' => 'string' }, 'required' => true },
+              { 'in' => 'formData', 'name' => "array_of_integer#{braces}", 'type' => 'array', 'items' => { 'type' => 'integer', 'format' => 'int32' }, 'required' => true }
+            ]
+          )
+        end
+      end
 
-  describe 'documentation for entity array parameters' do
-    let(:parameters) do
-      [
-        {
-          'in' => 'formData',
-          'name' => 'array_of_entities',
-          'type' => 'array',
-          'items' => {
-            '$ref' => '#/definitions/ApiError'
-          },
-          'required' => true
-        }
-      ]
-    end
+      describe 'documentation for entity array parameters' do
+        let(:parameters) do
+          [
+            {
+              'in' => 'formData',
+              'name' => "array_of_entities#{braces}",
+              'type' => 'array',
+              'items' => {
+                '$ref' => '#/definitions/ApiError'
+              },
+              'required' => true
+            }
+          ]
+        end
 
-    subject do
-      get '/swagger_doc/array_of_entities'
-      JSON.parse(last_response.body)
-    end
+        subject do
+          get '/swagger_doc/array_of_entities'
+          JSON.parse(last_response.body)
+        end
 
-    specify do
-      expect(subject['definitions']['ApiError']).not_to be_blank
-      expect(subject['paths']['/array_of_entities']['post']['parameters']).to eql(parameters)
+        specify do
+          expect(subject['definitions']['ApiError']).not_to be_blank
+          expect(subject['paths']['/array_of_entities']['post']['parameters']).to eql(parameters)
+        end
+      end
     end
   end
 end