grape-swagger 0.33.0 → 0.34.0

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