rswag-specs-2.1 2.9.1.ruby21

data/lib/rswag/specs/request_factory.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+require "active_support"
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/conversions'
+require 'json'
+
+module Rswag
+  module Specs
+    class RequestFactory
+      def initialize(config = ::Rswag::Specs.config)
+        @config = config
+      end
+
+      def build_request(metadata, example)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+        parameters = expand_parameters(metadata, swagger_doc, 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_payload(request, parameters, example)
+        end
+      end
+
+      private
+
+      def expand_parameters(metadata, swagger_doc, example)
+        operation_params = metadata[:operation][:parameters] || []
+        path_item_params = metadata[:path_item][:parameters] || []
+        security_params = derive_security_params(metadata, swagger_doc)
+
+        # 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 }
+          .uniq { |p| p[:name] }
+          .reject { |p| p[:required] == false && !example.respond_to?(extract_getter(p)) }
+      end
+
+      def derive_security_params(metadata, swagger_doc)
+        requirements = metadata[:operation][:security] || swagger_doc[:security] || []
+        scheme_names = requirements.flat_map(&:keys)
+        schemes = security_version(scheme_names, swagger_doc)
+
+        schemes.map do |scheme|
+          param = (scheme[:type] == :apiKey) ? scheme.slice(:name, :in) : { name: 'Authorization', in: :header }
+          param.merge(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)
+            ActiveSupport::Deprecation.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
+      end
+
+      def resolve_parameter(ref, swagger_doc)
+        key = key_version(ref, swagger_doc)
+        definitions = definition_version(swagger_doc)
+        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/')
+            ActiveSupport::Deprecation.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
+      end
+
+      def definition_version(swagger_doc)
+        if doc_version(swagger_doc).start_with?('2')
+          swagger_doc[:parameters]
+        else # Openapi3
+          if swagger_doc.key?(:parameters)
+            ActiveSupport::Deprecation.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
+      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
+        variables = {}
+        server.fetch(:variables, {}).each_pair { |k,v| variables[k] = v[use_server] }
+        base_path = server[:url].gsub(/\{(.*?)\}/) { variables[$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
+          ActiveSupport::Deprecation.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
+
+        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)")
+            end
+            path_template.gsub!("{#{p[:name]}}", example.send(extract_getter(p)).to_s)
+          end
+
+          parameters.select { |p| p[:in] == :query }.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))
+          end
+        end
+      end
+
+      def build_query_string_part(param, value, swagger_doc)
+        name = param[:name]
+
+        # 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
+          style = param[:style] ? param[:style].to_sym : :form
+          explode = param[:explode].nil? ? true : param[:explode]
+
+          # case param[:schema][:type]&.to_sym
+          case param[:schema][:type] ? param[:schema][:type].to_sym : nil
+          when :object
+            case style
+            when :deepObject
+              return { name => value }.to_query
+            when :form
+              if explode
+                return value.to_query
+              else
+                return "#{CGI.escape(name.to_s)}=" + 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| "#{CGI.escape(name.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+            else
+              separator = case style
+                          when :form then ','
+                          when :spaceDelimited then '%20'
+                          when :pipeDelimited then '|'
+                          end
+              return "#{CGI.escape(name.to_s)}=" + value.to_a.flatten.map{|v| CGI.escape(v.to_s) }.join(separator)
+            end
+          else
+            return "#{name}=#{value}"
+          end
+        end
+
+        # type = param[:type] || param.dig(:schema, :type)
+        type = param[:type] || (param[:schema] && param[:schema][:type])
+        # return "#{name}=#{value}" unless type&.to_sym == :array
+        return "#{name}=#{value}" unless type && 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
+        end
+      end
+
+      def add_headers(request, metadata, swagger_doc, parameters, example)
+        tuples = parameters
+          .select { |p| p[:in] == :header }
+          .map { |p| [p[:name], example.send(extract_getter(p)).to_s] }
+
+        # Accept header
+        produces = metadata[:operation][:produces] || swagger_doc[:produces]
+        if produces
+          accept = example.respond_to?(:Accept) ? example.send(:Accept) : produces.first
+          tuples << ['Accept', accept]
+        end
+
+        # Content-Type header
+        consumes = metadata[:operation][:consumes] || swagger_doc[:consumes]
+        if consumes
+          content_type = example.respond_to?(:'Content-Type') ? example.send(:'Content-Type') : consumes.first
+          tuples << ['Content-Type', content_type]
+        end
+
+        # Host header
+        host = metadata[:operation][:host] || swagger_doc[:host]
+        if host.present?
+          host = example.respond_to?(:'Host') ? example.send(:'Host') : host
+          tuples << ['Host', host]
+        end
+
+        # Rails test infrastructure requires rack-formatted headers
+        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]
+            end,
+            pair[1]
+          ]
+        end
+
+        request[:headers] = Hash[rack_formatted_tuples]
+      end
+
+      def add_payload(request, parameters, example)
+        content_type = request[:headers]['CONTENT_TYPE']
+        return if content_type.nil?
+
+        if ['application/x-www-form-urlencoded', 'multipart/form-data'].include?(content_type)
+          request[:payload] = build_form_payload(parameters, example)
+        else
+          request[:payload] = build_json_payload(parameters, example)
+        end
+      end
+
+      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))] }
+        Hash[tuples]
+      end
+
+      def build_json_payload(parameters, example)
+        body_param = parameters.select { |p| p[:in] == :body }.first
+
+        return nil unless body_param
+
+        raise(MissingParameterError, body_param[:name]) unless example.respond_to?(body_param[:name])
+
+        example.send(body_param[:name]).to_json
+      end
+
+      def doc_version(doc)
+        doc[:openapi] || doc[:swagger] || '3'
+      end
+
+      def extract_getter(parameter)
+         parameter[:getter] || parameter[:name]
+      end
+    end
+
+    class MissingParameterError < StandardError
+      attr_reader :body_param
+
+      def initialize(body_param)
+        @body_param = body_param
+      end
+
+      def message
+        <<-MSG
+          Missing parameter '#{body_param}'
+
+          Please check your spec. It looks like you defined a body parameter,
+          but did not declare usage via let. Try adding:
+
+              let(:#{body_param}) {}
+        MSG
+      end
+    end
+  end
+end

data/lib/rswag/specs/response_validator.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/slice'
+require 'json-schema'
+require 'json'
+require 'rswag/specs/extended_schema'
+
+module Rswag
+  module Specs
+    class ResponseValidator
+      def initialize(config = ::Rswag::Specs.config)
+        @config = config
+      end
+
+      def validate!(metadata, response)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+
+        validate_code!(metadata, response)
+        validate_headers!(metadata, response.headers)
+        validate_body!(metadata, swagger_doc, 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
+      end
+
+      def validate_headers!(metadata, headers)
+        header_schemas = (metadata[:response][:headers] || {})
+        expected = header_schemas.keys
+        expected.each do |name|
+          # nullable_attribute = header_schemas.dig(name.to_s, :schema, :nullable)
+          nullable_attribute = header_schemas[name.to_s] && header_schemas[name.to_s][:schema] && header_schemas[name.to_s][:schema][:nullable]
+          # required_attribute = header_schemas.dig(name.to_s, :required)
+          required_attribute = header_schemas[name.to_s] && header_schemas[name.to_s][:required]
+
+          is_nullable = nullable_attribute.nil? ? false : nullable_attribute
+          is_required = required_attribute.nil? ? true : required_attribute
+
+          if headers.exclude?(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"
+          end
+        end
+      end
+
+      def validate_body!(metadata, swagger_doc, body)
+        response_schema = metadata[:response][:schema]
+        return if response_schema.nil?
+
+        version = @config.get_swagger_doc_version(metadata[:swagger_doc])
+        schemas = definitions_or_component_schemas(swagger_doc, version)
+
+        validation_schema = response_schema
+          .merge('$schema' => 'http://tempuri.org/rswag/specs/extended_schema')
+          .merge(schemas)
+
+        validation_options = validation_options_from(metadata)
+
+        errors = JSON::Validator.fully_validate(validation_schema, body, validation_options)
+        return unless errors.any?
+
+        raise UnexpectedResponse,
+              "Expected response body to match schema: #{errors.join("\n")}\n" \
+              "Response body: #{JSON.pretty_generate(JSON.parse(body))}"
+      end
+
+      def validation_options_from(metadata)
+        is_strict = !!metadata.fetch(
+          :swagger_strict_schema_validation,
+          @config.swagger_strict_schema_validation
+        )
+
+        { strict: is_strict }
+      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)
+            ActiveSupport::Deprecation.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
+  end
+end

data/lib/rswag/specs/swagger_formatter.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/deep_merge'
+require 'rspec/core/formatters/base_text_formatter'
+require 'swagger_helper'
+
+module Rswag
+  module Specs
+    class SwaggerFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+      ActiveSupport::Deprecation.warn('Rswag::Specs: WARNING: Support for Ruby 2.6 will be dropped in v3.0') if RUBY_VERSION.start_with? '2.6'
+
+      if RSPEC_VERSION > 2
+        ::RSpec::Core::Formatters.register self, :example_group_finished, :stop
+      else
+        ActiveSupport::Deprecation.warn('Rswag::Specs: WARNING: Support for RSpec 2.X will be dropped in v3.0')
+      end
+
+      def initialize(output, config = Rswag::Specs.config)
+        @output = output
+        @config = config
+
+        @output.puts 'Generating Swagger docs ...'
+      end
+
+      def example_group_finished(notification)
+        metadata = if RSPEC_VERSION > 2
+          notification.group.metadata
+        else
+          notification.metadata
+        end
+
+        # !metadata[:document] won't work, since nil means we should generate
+        # docs.
+        return if metadata[:document] == false
+        return unless metadata.key?(:response)
+
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+
+        unless doc_version(swagger_doc).start_with?('2')
+          # This is called multiple times per file!
+          # metadata[:operation] is also re-used between examples within file
+          # therefore be careful NOT to modify its content here.
+          upgrade_request_type!(metadata)
+          upgrade_servers!(swagger_doc)
+          upgrade_oauth!(swagger_doc)
+          upgrade_response_produces!(swagger_doc, metadata)
+        end
+
+        swagger_doc.deep_merge!(metadata_to_swagger(metadata))
+      end
+
+      def stop(_notification = nil)
+        @config.swagger_docs.each do |url_path, doc|
+          unless doc_version(doc).start_with?('2')
+            # doc[:paths]&.each_pair do |_k, v|
+            (doc[:paths] || {}).each_pair do |_k, v|
+              v.each_pair do |_verb, value|
+                is_hash = value.is_a?(Hash)
+                if is_hash && value[:parameters]
+                  # schema_param = value[:parameters]&.find { |p| (p[:in] == :body || p[:in] == :formData) && p[:schema] }
+                  schema_param = (value[:parameters] || []).find { |p| (p[:in] == :body || p[:in] == :formData) && p[:schema] }
+                  mime_list = value[:consumes] || doc[:consumes]
+
+                  if value && schema_param && mime_list
+                    # value[:requestBody] = { content: {} } unless value.dig(:requestBody, :content)
+                    value[:requestBody] = { content: {} } unless value[:requestBody] && value[:requestBody][:content]
+                    value[:requestBody][:required] = true if schema_param[:required]
+                    value[:requestBody][:description] = schema_param[:description] if schema_param[:description]
+                    # examples = value.dig(:request_examples)
+                    examples = value[:request_examples]
+                    mime_list.each do |mime|
+                      value[:requestBody][:content][mime] = { schema: schema_param[:schema] }
+                      if examples
+                        value[:requestBody][:content][mime][:examples] ||= {}
+                        examples.map do |example|
+                          value[:requestBody][:content][mime][:examples][example[:name]] = {
+                            summary: example[:summary] || value[:summary],
+                            value: example[:value]
+                          }
+                        end
+                      end
+                    end
+                  end
+
+                  value[:parameters].reject! { |p| p[:in] == :body || p[:in] == :formData }
+                end
+                remove_invalid_operation_keys!(value)
+              end
+            end
+          end
+
+          file_path = File.join(@config.swagger_root, url_path)
+          dirname = File.dirname(file_path)
+          FileUtils.mkdir_p dirname unless File.exist?(dirname)
+
+          File.open(file_path, 'w') do |file|
+            file.write(pretty_generate(doc))
+          end
+
+          @output.puts "Swagger doc generated at #{file_path}"
+        end
+      end
+
+      private
+
+      def pretty_generate(doc)
+        if @config.swagger_format == :yaml
+          clean_doc = yaml_prepare(doc)
+          YAML.dump(clean_doc)
+        else # config errors are thrown in 'def swagger_format', no throw needed here
+          JSON.pretty_generate(doc)
+        end
+      end
+
+      def yaml_prepare(doc)
+        json_doc = JSON.pretty_generate(doc)
+        JSON.parse(json_doc)
+      end
+
+      def metadata_to_swagger(metadata)
+        response_code = metadata[:response][:code]
+        response = metadata[:response].reject { |k, _v| k == :code }
+
+        verb = metadata[:operation][:verb]
+        operation = metadata[:operation]
+          .reject { |k, _v| k == :verb }
+          .merge(responses: { response_code => response })
+
+        path_template = metadata[:path_item][:template]
+        path_item = metadata[:path_item]
+          .reject { |k, _v| k == :template }
+          .merge(verb => operation)
+
+        { paths: { path_template => path_item } }
+      end
+
+      def doc_version(doc)
+        doc[:openapi] || doc[:swagger] || '3'
+      end
+
+      def upgrade_response_produces!(swagger_doc, metadata)
+        # Accept header
+        mime_list = Array(metadata[:operation][:produces] || swagger_doc[:produces])
+        target_node = metadata[:response]
+        upgrade_content!(mime_list, target_node)
+        metadata[:response].delete(:schema)
+      end
+
+      def upgrade_content!(mime_list, target_node)
+        schema = target_node[:schema]
+        return if mime_list.empty? || schema.nil?
+
+        target_node[:content] ||= {}
+        mime_list.each do |mime_type|
+          # TODO: upgrade to have content-type specific schema
+          (target_node[:content][mime_type] ||= {}).merge!(schema: schema)
+        end
+      end
+
+      def upgrade_request_type!(metadata)
+        # No deprecation here as it seems valid to allow type as a shorthand
+        operation_nodes = metadata[:operation][:parameters] || []
+        path_nodes = metadata[:path_item][:parameters] || []
+        header_node = metadata[:response][:headers] || {}
+
+        (operation_nodes + path_nodes + [header_node]).each do |node|
+          if node && node[:type] && node[:schema].nil?
+            node[:schema] = { type: node[:type] }
+            node.delete(:type)
+          end
+        end
+      end
+
+      def upgrade_servers!(swagger_doc)
+        return unless swagger_doc[:servers].nil? && swagger_doc.key?(:schemes)
+
+        ActiveSupport::Deprecation.warn('Rswag::Specs: WARNING: schemes, host, and basePath are replaced in OpenAPI3! Rename to array of servers[{url}] (in swagger_helper.rb)')
+
+        swagger_doc[:servers] = { urls: [] }
+        swagger_doc[:schemes].each do |scheme|
+          swagger_doc[:servers][:urls] << scheme + '://' + swagger_doc[:host] + swagger_doc[:basePath]
+        end
+
+        swagger_doc.delete(:schemes)
+        swagger_doc.delete(:host)
+        swagger_doc.delete(:basePath)
+      end
+
+      def upgrade_oauth!(swagger_doc)
+        # find flow in securitySchemes (securityDefinitions will have been re-written)
+        # schemes = swagger_doc.dig(:components, :securitySchemes)
+        schemes = swagger_doc[:components] && swagger_doc[:components][:securitySchemes]
+        # return unless schemes&.any? { |_k, v| v.key?(:flow) }
+        return unless schemes && schemes.any? { |_k, v| v.key?(:flow) }
+
+        schemes.each do |name, v|
+          next unless v.key?(:flow)
+
+          ActiveSupport::Deprecation.warn("Rswag::Specs: WARNING: securityDefinitions flow is replaced in OpenAPI3! Rename to components/securitySchemes/#{name}/flows[] (in swagger_helper.rb)")
+          flow = swagger_doc[:components][:securitySchemes][name].delete(:flow).to_s
+          if flow == 'accessCode'
+            ActiveSupport::Deprecation.warn("Rswag::Specs: WARNING: securityDefinitions accessCode is replaced in OpenAPI3! Rename to clientCredentials (in swagger_helper.rb)")
+            flow = 'authorizationCode'
+          end
+          if flow == 'application'
+            ActiveSupport::Deprecation.warn("Rswag::Specs: WARNING: securityDefinitions application is replaced in OpenAPI3! Rename to authorizationCode (in swagger_helper.rb)")
+            flow = 'clientCredentials'
+          end
+          flow_elements = swagger_doc[:components][:securitySchemes][name].except(:type).each_with_object({}) do |(k, _v), a|
+            a[k] = swagger_doc[:components][:securitySchemes][name].delete(k)
+          end
+          swagger_doc[:components][:securitySchemes][name].merge!(flows: { flow => flow_elements })
+        end
+      end
+
+      def remove_invalid_operation_keys!(value)
+        return unless value.is_a?(Hash)
+
+        value.delete(:consumes) if value[:consumes]
+        value.delete(:produces) if value[:produces]
+        value.delete(:request_examples) if value[:request_examples]
+        value[:parameters].each { |p| p.delete(:getter) } if value[:parameters]
+      end
+    end
+  end
+end

data/lib/rswag/specs.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require 'rswag/specs/example_group_helpers'
+require 'rswag/specs/example_helpers'
+require 'rswag/specs/configuration'
+require 'rswag/specs/railtie' if defined?(Rails::Railtie)
+
+module Rswag
+  module Specs
+    # Extend RSpec with a swagger-based DSL
+    ::RSpec.configure do |c|
+      c.add_setting :swagger_root
+      c.add_setting :swagger_docs
+      c.add_setting :swagger_dry_run
+      c.add_setting :swagger_format
+      c.add_setting :swagger_strict_schema_validation
+      c.extend ExampleGroupHelpers, type: :request
+      c.include ExampleHelpers, type: :request
+    end
+
+    def self.config
+      @config ||= Configuration.new(RSpec.configuration)
+    end
+
+    # Support Rails 3+ and RSpec 2+ (sigh!)
+    RAILS_VERSION = Rails::VERSION::MAJOR
+    RSPEC_VERSION = RSpec::Core::Version::STRING.split('.').first.to_i
+  end
+end

data/lib/tasks/rswag-specs_tasks.rake

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+namespace :rswag do
+  namespace :specs do
+    desc 'Generate Swagger JSON files from integration specs'
+    RSpec::Core::RakeTask.new('swaggerize') do |t|
+      t.pattern = ENV.fetch(
+        'PATTERN',
+        'spec/requests/**/*_spec.rb, spec/api/**/*_spec.rb, spec/integration/**/*_spec.rb'
+      )
+
+      additional_rspec_opts = ENV.fetch(
+        'ADDITIONAL_RSPEC_OPTS',
+        ''
+      )
+
+      t.rspec_opts = [additional_rspec_opts]
+
+      if Rswag::Specs::RSPEC_VERSION > 2 && Rswag::Specs.config.swagger_dry_run
+        t.rspec_opts += ['--format Rswag::Specs::SwaggerFormatter', '--dry-run', '--order defined']
+      else
+        ActiveSupport::Deprecation.warn('Rswag::Specs: WARNING: Support for RSpec 2.X will be dropped in v3.0')
+        t.rspec_opts += ['--format Rswag::Specs::SwaggerFormatter', '--order defined']
+      end
+    end
+  end
+end
+
+task rswag: ['rswag:specs:swaggerize']