rswag-specs 2.15.0 → 3.0.0.pre

data/lib/rswag/specs/request_factory.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require "active_support"
+
+require 'active_support'
 require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/hash/conversions'
 require 'json'
@@ -7,217 +8,179 @@ require 'json'
 module Rswag
   module Specs
     class RequestFactory
-      def initialize(config = ::Rswag::Specs.config)
+      attr_accessor :example, :metadata, :params, :headers
+
+      def initialize(metadata, example, config = ::Rswag::Specs.config)
         @config = config
+        @example = example
+        @metadata = metadata
+        @params = example.respond_to?(:request_params) ? example.request_params : {}
+        @headers = example.respond_to?(:request_headers) ? example.request_headers : {}
       end
 
-      def build_request(metadata, example)
-        swagger_doc = @config.get_openapi_spec(metadata[:openapi_spec] || metadata[:swagger_doc])
-        parameters = expand_parameters(metadata, swagger_doc, example)
+      def build_request
+        openapi_spec = @config.get_openapi_spec(metadata[:openapi_spec])
+        parameters = expand_parameters(metadata, openapi_spec, example)
 
         {}.tap do |request|
           add_verb(request, metadata)
-          add_path(request, metadata, swagger_doc, parameters, example)
-          add_headers(request, metadata, swagger_doc, parameters, example)
+          add_path(request, metadata, openapi_spec, parameters, example)
+          add_headers(request, metadata, openapi_spec, parameters, example)
           add_payload(request, parameters, example)
         end
       end
 
       private
 
-      def expand_parameters(metadata, swagger_doc, example)
+      def expand_parameters(metadata, openapi_spec, _example)
         operation_params = metadata[:operation][:parameters] || []
         path_item_params = metadata[:path_item][:parameters] || []
-        security_params = derive_security_params(metadata, swagger_doc)
+        security_params = derive_security_params(metadata, openapi_spec)
 
         # NOTE: Use of + instead of concat to avoid mutation of the metadata object
         (operation_params + path_item_params + security_params)
-          .map { |p| p['$ref'] ? resolve_parameter(p['$ref'], swagger_doc) : p }
+          .map { |p| p['$ref'] ? resolve_parameter(p['$ref'], openapi_spec) : p }
           .uniq { |p| p[:name] }
-          .reject { |p| p[:required] == false && !example.respond_to?(extract_getter(p)) }
+          .reject do |p|
+            p[:required] == false &&
+              !headers.key?(p[:name]) &&
+              !params.key?(p[:name])
+          end
       end
 
-      def derive_security_params(metadata, swagger_doc)
-        requirements = metadata[:operation][:security] || swagger_doc[:security] || []
+      def derive_security_params(metadata, openapi_spec)
+        requirements = metadata[:operation][:security] || openapi_spec[:security] || []
         scheme_names = requirements.flat_map(&:keys)
-        schemes = security_version(scheme_names, swagger_doc)
+        schemes = security_version(scheme_names, openapi_spec)
 
         schemes.map do |scheme|
-          param = (scheme[:type] == :apiKey) ? scheme.slice(:name, :in) : { name: 'Authorization', in: :header }
-          param.merge(type: :string, required: requirements.one?)
+          param = scheme[:type] == :apiKey ? scheme.slice(:name, :in) : { name: 'Authorization', in: :header }
+          param.merge(schema: { type: :string }, required: requirements.one?)
         end
       end
 
-      def security_version(scheme_names, swagger_doc)
-        if doc_version(swagger_doc).start_with?('2')
-          (swagger_doc[:securityDefinitions] || {}).slice(*scheme_names).values
-        else # Openapi3
-          if swagger_doc.key?(:securityDefinitions)
-            Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: securityDefinitions is replaced in OpenAPI3! Rename to components/securitySchemes (in swagger_helper.rb)')
-            swagger_doc[:components] ||= { securitySchemes: swagger_doc[:securityDefinitions] }
-            swagger_doc.delete(:securityDefinitions)
-          end
-          components = swagger_doc[:components] || {}
-          (components[:securitySchemes] || {}).slice(*scheme_names).values
-        end
+      def security_version(scheme_names, openapi_spec)
+        components = openapi_spec[:components] || {}
+        (components[:securitySchemes] || {}).slice(*scheme_names).values
       end
 
-      def resolve_parameter(ref, swagger_doc)
-        key = key_version(ref, swagger_doc)
-        definitions = definition_version(swagger_doc)
+      def resolve_parameter(ref, openapi_spec)
+        key = key_version(ref, openapi_spec)
+        definitions = definition_version(openapi_spec)
         raise "Referenced parameter '#{ref}' must be defined" unless definitions && definitions[key]
 
         definitions[key]
       end
 
-      def key_version(ref, swagger_doc)
-        if doc_version(swagger_doc).start_with?('2')
-          ref.sub('#/parameters/', '').to_sym
-        else # Openapi3
-          if ref.start_with?('#/parameters/')
-            Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: #/parameters/ refs are replaced in OpenAPI3! Rename to #/components/parameters/')
-            ref.sub('#/parameters/', '').to_sym
-          else
-            ref.sub('#/components/parameters/', '').to_sym
-          end
-        end
+      def key_version(ref, _openapi_spec)
+        ref.sub('#/components/parameters/', '').to_sym
       end
 
-      def definition_version(swagger_doc)
-        if doc_version(swagger_doc).start_with?('2')
-          swagger_doc[:parameters]
-        else # Openapi3
-          if swagger_doc.key?(:parameters)
-            Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: parameters is replaced in OpenAPI3! Rename to components/parameters (in swagger_helper.rb)')
-            swagger_doc[:parameters]
-          else
-            components = swagger_doc[:components] || {}
-            components[:parameters]
-          end
-        end
+      def definition_version(openapi_spec)
+        components = openapi_spec[:components] || {}
+        components[:parameters]
       end
 
       def add_verb(request, metadata)
         request[:verb] = metadata[:operation][:verb]
       end
 
-      def base_path_from_servers(swagger_doc, use_server = :default)
-        return '' if swagger_doc[:servers].nil? || swagger_doc[:servers].empty?
-        server = swagger_doc[:servers].first
+      def base_path_from_servers(openapi_spec, use_server = :default)
+        return '' if openapi_spec[:servers].nil? || openapi_spec[:servers].empty?
+
+        server = openapi_spec[:servers].first
         variables = {}
-        server.fetch(:variables, {}).each_pair { |k,v| variables[k] = v[use_server] }
-        base_path = server[:url].gsub(/\{(.*?)\}/) { variables[$1.to_sym] }
+        server.fetch(:variables, {}).each_pair { |k, v| variables[k] = v[use_server] }
+        base_path = server[:url].gsub(/\{(.*?)\}/) { variables[::Regexp.last_match(1).to_sym] }
         URI(base_path).path
       end
 
-      def add_path(request, metadata, swagger_doc, parameters, example)
-        open_api_3_doc = doc_version(swagger_doc).start_with?('3')
-        uses_base_path = swagger_doc[:basePath].present?
-
-        if open_api_3_doc && uses_base_path
-          Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: basePath is replaced in OpenAPI3! Update your swagger_helper.rb')
-        end
-
-        if uses_base_path
-          template = (swagger_doc[:basePath] || '') + metadata[:path_item][:template]
-        else # OpenAPI 3
-          template = base_path_from_servers(swagger_doc) + metadata[:path_item][:template]
-        end
+      def add_path(request, metadata, openapi_spec, parameters, _example)
+        template = base_path_from_servers(openapi_spec) + metadata[:path_item][:template]
 
         request[:path] = template.tap do |path_template|
           parameters.select { |p| p[:in] == :path }.each do |p|
-            unless example.respond_to?(extract_getter(p))
-              raise ArgumentError.new("`#{p[:name].to_s}` parameter key present, but not defined within example group"\
-                "(i. e `it` or `let` block)")
+            begin
+              param_value = params.fetch(p[:name].to_s).to_s
+            rescue KeyError
+              raise ArgumentError, ("`#{p[:name]}`" \
+                'parameter key present, but not defined within example group' \
+                '(i. e `it` or `let` block)')
             end
-            path_template.gsub!("{#{p[:name]}}", example.send(extract_getter(p)).to_s)
+            path_template.gsub!("{#{p[:name]}}", param_value)
           end
 
-          parameters.select { |p| p[:in] == :query }.each_with_index do |p, i|
+          parameters.select { |p| p[:in] == :query && params.key?(p[:name]) }.each_with_index do |p, i|
             path_template.concat(i.zero? ? '?' : '&')
-            path_template.concat(build_query_string_part(p, example.send(extract_getter(p)), swagger_doc))
+            path_template.concat(build_query_string_part(p, params.fetch(p[:name]), openapi_spec))
           end
         end
       end
 
-      def build_query_string_part(param, value, swagger_doc)
+      def build_query_string_part(param, value, _openapi_spec)
+        raise ArgumentError, "'type' is not supported field for Parameter" unless param[:type].nil?
+
         name = param[:name]
         escaped_name = CGI.escape(name.to_s)
 
-        # OAS 3: https://swagger.io/docs/specification/serialization/
-        if swagger_doc && doc_version(swagger_doc).start_with?('3') && param[:schema]
-          style = param[:style]&.to_sym || :form
-          explode = param[:explode].nil? ? true : param[:explode]
-
-          case param[:schema][:type]&.to_sym
-          when :object
-            case style
-            when :deepObject
-              return { name => value }.to_query
-            when :form
-              if explode
-                return value.to_query
-              else
-                return "#{escaped_name}=" + value.to_a.flatten.map{|v| CGI.escape(v.to_s) }.join(',')
-              end
-            end
-          when :array
-            case explode
-            when true
-              return value.to_a.flatten.map{|v| "#{escaped_name}=#{CGI.escape(v.to_s)}"}.join('&')
-            else
-              separator = case style
-                          when :form then ','
-                          when :spaceDelimited then '%20'
-                          when :pipeDelimited then '|'
-                          end
-              return "#{escaped_name}=" + value.to_a.flatten.map{|v| CGI.escape(v.to_s) }.join(separator)
-            end
+        # NOTE: https://swagger.io/docs/specification/serialization/
+        return unless param[:schema]
+
+        style = param[:style]&.to_sym || :form
+        explode = param[:explode].nil? || param[:explode]
+        type = param.dig(:schema, :type)&.to_sym
+
+        case type
+        when :object
+          case style
+          when :deepObject
+            { name => value }.to_query
+          when :form
+            return value.to_query if explode
+
+            "#{escaped_name}=" + value.to_a.flatten.map { |v| CGI.escape(v.to_s) }.join(',')
+
+          end
+        when :array
+          case explode
+          when true
+            value.to_a.flatten.map { |v| "#{escaped_name}=#{CGI.escape(v.to_s)}" }.join('&')
           else
-            return "#{escaped_name}=#{CGI.escape(value.to_s)}"
+            separator = case style
+                        when :form then ','
+                        when :spaceDelimited then '%20'
+                        when :pipeDelimited then '|'
+                        end
+            "#{escaped_name}=" + value.to_a.flatten.map { |v| CGI.escape(v.to_s) }.join(separator)
           end
-        end
-
-        type = param[:type] || param.dig(:schema, :type)
-        return "#{escaped_name}=#{CGI.escape(value.to_s)}" unless type&.to_sym == :array
-
-        case param[:collectionFormat]
-        when :ssv
-          "#{name}=#{value.join(' ')}"
-        when :tsv
-          "#{name}=#{value.join('\t')}"
-        when :pipes
-          "#{name}=#{value.join('|')}"
-        when :multi
-          value.map { |v| "#{name}=#{v}" }.join('&')
         else
-          "#{name}=#{value.join(',')}" # csv is default
+          "#{escaped_name}=#{CGI.escape(value.to_s)}"
         end
       end
 
-      def add_headers(request, metadata, swagger_doc, parameters, example)
+      def add_headers(request, metadata, openapi_spec, parameters, example)
         tuples = parameters
-          .select { |p| p[:in] == :header }
-          .map { |p| [p[:name], example.send(extract_getter(p)).to_s] }
+                 .select { |p| p[:in] == :header }
+                 .map { |p| [p[:name], headers.fetch(p[:name]).to_s] }
 
         # Accept header
-        produces = metadata[:operation][:produces] || swagger_doc[:produces]
+        produces = metadata[:operation][:produces] || openapi_spec[:produces]
         if produces
-          accept = example.respond_to?(:Accept) ? example.send(:Accept) : produces.first
+          accept = headers.fetch('Accept', produces.first)
           tuples << ['Accept', accept]
         end
 
         # Content-Type header
-        consumes = metadata[:operation][:consumes] || swagger_doc[:consumes]
+        consumes = metadata[:operation][:consumes] || openapi_spec[:consumes]
         if consumes
-          content_type = example.respond_to?(:'Content-Type') ? example.send(:'Content-Type') : consumes.first
+          content_type = headers.fetch('Content-Type', consumes.first)
           tuples << ['Content-Type', content_type]
         end
 
         # Host header
-        host = metadata[:operation][:host] || swagger_doc[:host]
+        host = metadata[:operation][:host] || openapi_spec[:host]
         if host.present?
-          host = example.respond_to?(:'Host') ? example.send(:'Host') : host
+          host = example.respond_to?(:Host) ? example.send(:Host) : host
           tuples << ['Host', host]
         end
 
@@ -225,11 +188,11 @@ module Rswag
         rack_formatted_tuples = tuples.map do |pair|
           [
             case pair[0]
-              when 'Accept' then 'HTTP_ACCEPT'
-              when 'Content-Type' then 'CONTENT_TYPE'
-              when 'Authorization' then 'HTTP_AUTHORIZATION'
-              when 'Host' then 'HTTP_HOST'
-              else pair[0]
+            when 'Accept' then 'HTTP_ACCEPT'
+            when 'Content-Type' then 'CONTENT_TYPE'
+            when 'Authorization' then 'HTTP_AUTHORIZATION'
+            when 'Host' then 'HTTP_HOST'
+            else pair[0]
             end,
             pair[1]
           ]
@@ -244,31 +207,35 @@ module Rswag
 
         request[:payload] = if ['application/x-www-form-urlencoded', 'multipart/form-data'].include?(content_type)
                               build_form_payload(parameters, example)
-                            elsif content_type =~ /\Aapplication\/([0-9A-Za-z._-]+\+json\z|json\z)/
+                            elsif %r{\Aapplication/([0-9A-Za-z._-]+\+json\z|json\z)}.match?(content_type)
                               build_json_payload(parameters, example)
                             else
                               build_raw_payload(parameters, example)
                             end
       end
 
-      def build_form_payload(parameters, example)
+      def build_form_payload(parameters, _example)
         # See http://seejohncode.com/2012/04/29/quick-tip-testing-multipart-uploads-with-rspec/
         # Rather that serializing with the appropriate encoding (e.g. multipart/form-data),
         # Rails test infrastructure allows us to send the values directly as a hash
         # PROS: simple to implement, CONS: serialization/deserialization is bypassed in test
         tuples = parameters
-          .select { |p| p[:in] == :formData }
-          .map { |p| [p[:name], example.send(extract_getter(p))] }
+                 .select { |p| p[:in] == :formData }
+                 .map { |p| [p[:name], params.fetch(p[:name])] }
         Hash[tuples]
       end
 
-      def build_raw_payload(parameters, example)
-        body_param = parameters.select { |p| p[:in] == :body }.first
+      def build_raw_payload(parameters, _example)
+        body_param = parameters.find { |p| p[:in] == :body }
         return nil unless body_param
 
-        raise(MissingParameterError, body_param[:name]) unless example.respond_to?(body_param[:name])
+        begin
+          json_payload = params.fetch(body_param[:name].to_s)
+        rescue KeyError
+          raise(MissingParameterError, body_param[:name])
+        end
 
-        example.send(body_param[:name])
+        json_payload
       end
 
       def build_json_payload(parameters, example)
@@ -276,11 +243,7 @@ module Rswag
       end
 
       def doc_version(doc)
-        doc[:openapi] || doc[:swagger] || '3'
-      end
-
-      def extract_getter(parameter)
-         parameter[:getter] || parameter[:name]
+        doc[:openapi]
       end
     end
 

data/lib/rswag/specs/response_validator.rb

@@ -13,54 +13,55 @@ module Rswag
       end
 
       def validate!(metadata, response)
-        swagger_doc = @config.get_openapi_spec(metadata[:openapi_spec] || metadata[:swagger_doc])
+        openapi_spec = @config.get_openapi_spec(metadata[:openapi_spec])
 
         validate_code!(metadata, response)
         validate_headers!(metadata, response.headers)
-        validate_body!(metadata, swagger_doc, response.body)
+        validate_body!(metadata, openapi_spec, response.body)
       end
 
       private
 
       def validate_code!(metadata, response)
         expected = metadata[:response][:code].to_s
-        if response.code != expected
-          raise UnexpectedResponse,
-            "Expected response code '#{response.code}' to match '#{expected}'\n" \
-              "Response body: #{response.body}"
-        end
+        return unless response.code != expected
+
+        raise UnexpectedResponse,
+              "Expected response code '#{response.code}' to match '#{expected}'\n" \
+                "Response body: #{response.body}"
       end
 
       def validate_headers!(metadata, headers)
-        header_schemas = (metadata[:response][:headers] || {})
+        header_schemas = metadata[:response][:headers] || {}
         expected = header_schemas.keys
         expected.each do |name|
           nullable_attribute = header_schemas.dig(name.to_s, :schema, :nullable)
           required_attribute = header_schemas.dig(name.to_s, :required)
 
           is_nullable = nullable_attribute.nil? ? false : nullable_attribute
-          is_required = required_attribute.nil? ? true : required_attribute
+          is_required = required_attribute.nil? || required_attribute
 
-          if headers.exclude?(name.to_s) && is_required
-            raise UnexpectedResponse, "Expected response header #{name} to be present"
+          if !headers.include?(name.to_s) && is_required
+            raise UnexpectedResponse,
+                  "Expected response header #{name} to be present"
           end
 
           if headers.include?(name.to_s) && headers[name.to_s].nil? && !is_nullable
-            raise UnexpectedResponse, "Expected response header #{name} to not be null"
+            raise UnexpectedResponse,
+                  "Expected response header #{name} to not be null"
           end
         end
       end
 
-      def validate_body!(metadata, swagger_doc, body)
+      def validate_body!(metadata, openapi_spec, body)
         response_schema = metadata[:response][:schema]
         return if response_schema.nil?
 
-        version = @config.get_openapi_spec_version(metadata[:openapi_spec] || metadata[:swagger_doc])
-        schemas = definitions_or_component_schemas(swagger_doc, version)
+        schemas = { components: openapi_spec[:components] }
 
         validation_schema = response_schema
-          .merge('$schema' => 'http://tempuri.org/rswag/specs/extended_schema')
-          .merge(schemas)
+                            .merge('$schema' => 'http://tempuri.org/rswag/specs/extended_schema')
+                            .merge(schemas)
 
         validation_options = validation_options_from(metadata)
 
@@ -73,39 +74,16 @@ module Rswag
       end
 
       def validation_options_from(metadata)
-        is_strict = @config.openapi_strict_schema_validation
-
-        if metadata.key?(:swagger_strict_schema_validation)
-          Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: This option will be removed in v3.0 please use openapi_all_properties_required and openapi_no_additional_properties set to true')
-          is_strict = !!metadata[:swagger_strict_schema_validation]
-        elsif metadata.key?(:openapi_strict_schema_validation)
-          Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: This option will be removed in v3.0 please use openapi_all_properties_required and openapi_no_additional_properties set to true')
-          is_strict = !!metadata[:openapi_strict_schema_validation]
-        end
-
-        all_properties_required = metadata.fetch(:openapi_all_properties_required, @config.openapi_all_properties_required)
-        no_additional_properties = metadata.fetch(:openapi_no_additional_properties, @config.openapi_no_additional_properties)
+        all_properties_required = metadata.fetch(:openapi_all_properties_required,
+                                                 @config.openapi_all_properties_required)
+        no_additional_properties = metadata.fetch(:openapi_no_additional_properties,
+                                                  @config.openapi_no_additional_properties)
 
         {
-          strict: is_strict,
           allPropertiesRequired: all_properties_required,
           noAdditionalProperties: no_additional_properties
         }
       end
-
-      def definitions_or_component_schemas(swagger_doc, version)
-        if version.start_with?('2')
-          swagger_doc.slice(:definitions)
-        else # Openapi3
-          if swagger_doc.key?(:definitions)
-            Rswag::Specs.deprecator.warn('Rswag::Specs: WARNING: definitions is replaced in OpenAPI3! Rename to components/schemas (in swagger_helper.rb)')
-            swagger_doc.slice(:definitions)
-          else
-            components = swagger_doc[:components] || {}
-            { components: components }
-          end
-        end
-      end
     end
 
     class UnexpectedResponse < StandardError; end

data/lib/rswag/specs.rb

@@ -8,21 +8,12 @@ require 'rswag/specs/railtie' if defined?(Rails::Railtie)
 
 module Rswag
   module Specs
-    RENAMED_METHODS = {
-      swagger_root: :openapi_root,
-      swagger_docs: :openapi_specs,
-      swagger_dry_run: :rswag_dry_run,
-      swagger_format: :openapi_format
-    }.freeze
-    private_constant :RENAMED_METHODS
-
     # Extend RSpec with a swagger-based DSL
     ::RSpec.configure do |c|
       c.add_setting :openapi_root
       c.add_setting :openapi_specs
       c.add_setting :rswag_dry_run
       c.add_setting :openapi_format, default: :json
-      c.add_setting :openapi_strict_schema_validation
       c.add_setting :openapi_all_properties_required
       c.add_setting :openapi_no_additional_properties
       c.extend ExampleGroupHelpers, type: :request
@@ -32,41 +23,5 @@ module Rswag
     def self.config
       @config ||= Configuration.new(RSpec.configuration)
     end
-
-    def self.deprecator
-      @deprecator ||= ActiveSupport::Deprecation.new('3.0', 'rswag-specs')
-    end
-
-    # Support Rails 3+ and RSpec 2+ (sigh!)
-    RAILS_VERSION = Rails::VERSION::MAJOR
-    RSPEC_VERSION = RSpec::Core::Version::STRING.split('.').first.to_i
-
-    RSpec::Core::Configuration.class_eval do
-      RENAMED_METHODS.each do |old_name, new_name|
-        define_method("#{old_name}=") do |*args, &block|
-          public_send("#{new_name}=", *args, &block)
-        end
-      end
-
-      define_method('swagger_strict_schema_validation=') do |*args, &block|
-        public_send('openapi_strict_schema_validation=', *args, &block)
-      end
-    end
-
-    Specs.deprecator.deprecate_methods(
-      RSpec::Core::Configuration,
-      RENAMED_METHODS.to_h { |old_name, new_name| ["#{old_name}=".to_sym, "#{new_name}=".to_sym] }
-    )
-
-    Specs.deprecator.deprecate_methods(
-      RSpec::Core::Configuration,
-      :openapi_strict_schema_validation= => 'use openapi_all_properties_required and openapi_no_additional_properties set to true'
-    )
-
-    if RUBY_VERSION.start_with? '2.6'
-      Specs.deprecator.warn('Rswag::Specs: WARNING: Support for Ruby 2.6 will be dropped in v3.0')
-    end
-
-    Specs.deprecator.warn('Rswag::Specs: WARNING: Support for RSpec 2.X will be dropped in v3.0') if RSPEC_VERSION < 3
   end
 end

data/lib/tasks/rswag-specs_tasks.rake

@@ -4,7 +4,7 @@ require 'rspec/core/rake_task'
 
 namespace :rswag do
   namespace :specs do
-    desc 'Generate Swagger JSON files from integration specs'
+    desc 'Generate OpenAPI JSON files from integration specs'
     RSpec::Core::RakeTask.new('swaggerize') do |t|
       t.pattern = ENV.fetch(
         'PATTERN',
@@ -16,13 +16,12 @@ namespace :rswag do
         ''
       )
 
-      t.rspec_opts = [additional_rspec_opts]
+      t.rspec_opts = [
+        '--format Rswag::Specs::OpenapiFormatter',
+        '--order defined'
+      ] << additional_rspec_opts
 
-      if Rswag::Specs.config.rswag_dry_run
-        t.rspec_opts += ['--format Rswag::Specs::SwaggerFormatter', '--dry-run', '--order defined']
-      else
-        t.rspec_opts += ['--format Rswag::Specs::SwaggerFormatter', '--order defined']
-      end
+      t.rspec_opts += ['--dry-run'] if Rswag::Specs.config.rswag_dry_run
     end
   end
 end