grape-swagger 0.33.0 → 0.34.2

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/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_response_with_root_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'response with root' do
+  include_context "#{MODEL_PARSER} swagger example"
+
+  before :all do
+    module TheApi
+      class ResponseApiWithRoot < Grape::API
+        format :json
+
+        desc 'This returns something',
+             http_codes: [{ code: 200, model: Entities::Something }]
+        get '/ordinary_response' do
+          { 'declared_params' => declared(params) }
+        end
+
+        desc 'This returns something',
+             is_array: true,
+             http_codes: [{ code: 200, model: Entities::Something }]
+        get '/response_with_array' do
+          { 'declared_params' => declared(params) }
+        end
+
+        route_setting :swagger, root: true
+        desc 'This returns something',
+             http_codes: [{ code: 200, model: Entities::Something }]
+        get '/response_with_root' do
+          { 'declared_params' => declared(params) }
+        end
+
+        route_setting :swagger, root: true
+        desc 'This returns underscored root',
+             http_codes: [{ code: 200, model: Entities::ApiError }]
+        get '/response_with_root_underscore' do
+          { 'declared_params' => declared(params) }
+        end
+
+        route_setting :swagger, root: true
+        desc 'This returns something',
+             is_array: true,
+             http_codes: [{ code: 200, model: Entities::Something }]
+        get '/response_with_array_and_root' do
+          { 'declared_params' => declared(params) }
+        end
+
+        route_setting :swagger, root: 'custom_root'
+        desc 'This returns something',
+             http_codes: [{ code: 200, model: Entities::Something }]
+        get '/response_with_custom_root' do
+          { 'declared_params' => declared(params) }
+        end
+
+        add_swagger_documentation
+      end
+    end
+  end
+
+  def app
+    TheApi::ResponseApiWithRoot
+  end
+
+  describe 'GET /ordinary_response' do
+    subject do
+      get '/swagger_doc/ordinary_response'
+      JSON.parse(last_response.body)
+    end
+
+    it 'does not add root or array' do
+      schema = subject.dig('paths', '/ordinary_response', 'get', 'responses', '200', 'schema')
+      expect(schema).to eq(
+        '$ref' => '#/definitions/Something'
+      )
+    end
+  end
+
+  describe 'GET /response_with_array' do
+    subject do
+      get '/swagger_doc/response_with_array'
+      JSON.parse(last_response.body)
+    end
+
+    it 'adds array to the response' do
+      schema = subject.dig('paths', '/response_with_array', 'get', 'responses', '200', 'schema')
+      expect(schema).to eq(
+        'type' => 'array', 'items' => { '$ref' => '#/definitions/Something' }
+      )
+    end
+  end
+
+  describe 'GET /response_with_root' do
+    subject do
+      get '/swagger_doc/response_with_root'
+      JSON.parse(last_response.body)
+    end
+
+    it 'adds root to the response' do
+      schema = subject.dig('paths', '/response_with_root', 'get', 'responses', '200', 'schema')
+      expect(schema).to eq(
+        'type' => 'object',
+        'properties' => { 'something' => { '$ref' => '#/definitions/Something' } }
+      )
+    end
+  end
+
+  describe 'GET /response_with_root_underscore' do
+    subject do
+      get '/swagger_doc/response_with_root_underscore'
+      JSON.parse(last_response.body)
+    end
+
+    it 'adds root to the response' do
+      schema = subject.dig('paths', '/response_with_root_underscore', 'get', 'responses', '200', 'schema')
+      expect(schema).to eq(
+        'type' => 'object',
+        'properties' => { 'api_error' => { '$ref' => '#/definitions/ApiError' } }
+      )
+    end
+  end
+
+  describe 'GET /response_with_array_and_root' do
+    subject do
+      get '/swagger_doc/response_with_array_and_root'
+      JSON.parse(last_response.body)
+    end
+
+    it 'adds root and array to the response' do
+      schema = subject.dig('paths', '/response_with_array_and_root', 'get', 'responses', '200', 'schema')
+      expect(schema).to eq(
+        'type' => 'object',
+        'properties' => {
+          'somethings' => { 'type' => 'array', 'items' => { '$ref' => '#/definitions/Something' } }
+        }
+      )
+    end
+  end
+
+  describe 'GET /response_with_custom_root' do
+    subject do
+      get '/swagger_doc/response_with_custom_root'
+      JSON.parse(last_response.body)
+    end
+
+    it 'adds root to the response' do
+      schema = subject.dig('paths', '/response_with_custom_root', 'get', 'responses', '200', 'schema')
+      expect(schema).to eq(
+        'type' => 'object',
+        'properties' => { 'custom_root' => { '$ref' => '#/definitions/Something' } }
+      )
+    end
+  end
+end

data/spec/swagger_v2/description_not_initialized_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'has no description, if details or description are nil' do
+  include_context "#{MODEL_PARSER} swagger example"
+
+  before :all do
+    module TheApi
+      class GfmRcDetailApi < Grape::API
+        format :json
+
+        desc nil,
+             detail: nil,
+             entity: Entities::UseResponse,
+             failure: [{ code: 400, model: Entities::ApiError }]
+        get '/use_gfm_rc_detail' do
+          { 'declared_params' => declared(params) }
+        end
+
+        add_swagger_documentation
+      end
+    end
+  end
+
+  def app
+    TheApi::GfmRcDetailApi
+  end
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  specify do
+    expect(subject['paths']['/use_gfm_rc_detail']['get']).not_to include('description')
+    expect(subject['paths']['/use_gfm_rc_detail']['get']['description']).to eql(nil)
+  end
+end

data/spec/swagger_v2/endpoint_versioned_path_spec.rb

@@ -52,6 +52,39 @@ describe 'Grape::Endpoint#path_and_definitions' do
         expect(subject.first['/v1/item'][:get][:tags]).to eq ['special-item']
       end
     end
+
+    context 'when parameter with a custom type is specified' do
+      let(:item) do
+        Class.new(Grape::API) do
+          Color = Struct.new(:value) do
+            def self.parse(value)
+              new(value: value)
+            end
+          end
+
+          class ColorEntity < Grape::Entity
+            expose :value
+          end
+
+          version 'v1', using: :path
+
+          resource :item do
+            params do
+              requires :root, type: Hash do
+                optional :color, type: Color, documentation: { type: ColorEntity }
+              end
+            end
+            post '/'
+          end
+        end
+      end
+
+      it 'creates a reference to the model instead of using the non-existent type' do
+        color = subject.dig(1, 'postV1Item', :properties, :root, :properties, :color)
+        expect(color).not_to eq(type: 'ColorEntity')
+        expect(color).to eq('$ref' => '#/definitions/ColorEntity')
+      end
+    end
   end
 
   context 'when mounting an API more than once', if: GrapeVersion.satisfy?('>= 1.2.0') do

data/spec/swagger_v2/mounted_target_class_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe 'docs mounted separately from api' do
+xdescribe 'docs mounted separately from api' do
   before :all do
     class ActualApi < Grape::API
       desc 'Document root'