scorpio 0.6.4 → 0.7.0

data/lib/scorpio/openapi.rb

@@ -2,7 +2,7 @@
 
 module Scorpio
   module OpenAPI
-    class Error < StandardError
+    class Error < Scorpio::Error
     end
     # an error in the semantics of an openapi document. for example, an Operation with
     # two body parameters (in v2, not possible in v3) is a SemanticError. an Operation
@@ -18,219 +18,39 @@ module Scorpio
     autoload :Document, 'scorpio/openapi/document'
     autoload :Reference, 'scorpio/openapi/reference'
     autoload :Tag, 'scorpio/openapi/tag'
+    autoload(:Tags, 'scorpio/openapi/tag')
+    autoload(:Server, 'scorpio/openapi/server')
     autoload :OperationsScope, 'scorpio/openapi/operations_scope'
 
-    module V3
-      openapi_document_schema = JSI::JSONSchemaDraft04.new_schema(::YAML.load_file(Scorpio.root.join(
-        'documents/github.com/OAI/OpenAPI-Specification/blob/oas3-schema/schemas/v3.0/schema.yaml'
-      )))
-
-      # the schema represented by Scorpio::OpenAPI::V3::Schema will describe schemas itself.
-      # JSI::Schema#describes_schema! enables this to implement the functionality of schemas.
-      describe_schema = [
-        openapi_document_schema.definitions['Schema'],
-        openapi_document_schema.definitions['SchemaReference'],
-        # instead of the Schema definition allowing boolean, properties['additionalProperties']
-        # is a oneOf which allows a Schema, SchemaReference, or boolean.
-        # instances of the former two already include the schema implementation (per the previous
-        # describes_schema entries), but the boolean does not.
-        # including in properties['additionalProperties'] applies to any additionalProperties.
-        # (including in properties['additionalProperties'].anyOf[2] would extend booleans too, without
-        # the redundant inclusion that results for Schema and SchemaRef, but redundant inclusion is not
-        # a problem, and this way also applies when none of the anyOf match due to schema errors.)
-        openapi_document_schema.definitions['Schema'].properties['additionalProperties'],
-      ]
-      describe_schema.each { |s| s.describes_schema!([JSI::Schema::Draft04]) }
-
-      Document = openapi_document_schema.jsi_schema_module
-
-      # naming these is not strictly necessary, but is nice to have.
-      # generated: `puts Scorpio::OpenAPI::V3::Document.schema.definitions.keys.map { |k| "#{k[0].upcase}#{k[1..-1]} = Document.definitions['#{k}']" }`
-
-
-      Reference      = Document.definitions['Reference']
-      SchemaReference = Document.definitions['SchemaReference']
-      Info           = Document.definitions['Info']
-      Contact       = Document.definitions['Contact']
-      License       = Document.definitions['License']
-      Server         = Document.definitions['Server']
-      ServerVariable  = Document.definitions['ServerVariable']
-      Components       = Document.definitions['Components']
-      Schema            = Document.definitions['Schema']
-      Discriminator      = Document.definitions['Discriminator']
-      XML                 = Document.definitions['XML']
-      Response             = Document.definitions['Response']
-      MediaType             = Document.definitions['MediaType']
-      MediaTypeWithExample   = Document.definitions['MediaTypeWithExample']
-      MediaTypeWithExamples   = Document.definitions['MediaTypeWithExamples']
-      Example                  = Document.definitions['Example']
-      Header                    = Document.definitions['Header']
-      HeaderWithSchema           = Document.definitions['HeaderWithSchema']
-      HeaderWithSchemaWithExample = Document.definitions['HeaderWithSchemaWithExample']
-      HeaderWithSchemaWithExamples = Document.definitions['HeaderWithSchemaWithExamples']
-      HeaderWithContent           = Document.definitions['HeaderWithContent']
-      Paths                      = Document.definitions['Paths']
-      PathItem                    = Document.definitions['PathItem']
-      Operation                    = Document.definitions['Operation']
-      Responses                     = Document.definitions['Responses']
-      SecurityRequirement            = Document.definitions['SecurityRequirement']
-      Tag                             = Document.definitions['Tag']
-      ExternalDocumentation            = Document.definitions['ExternalDocumentation']
-      Parameter                         = Document.definitions['Parameter']
-      ParameterWithSchema                = Document.definitions['ParameterWithSchema']
-      ParameterWithSchemaWithExample      = Document.definitions['ParameterWithSchemaWithExample']
-      ParameterWithSchemaWithExampleInPath = Document.definitions['ParameterWithSchemaWithExampleInPath']
-      ParameterWithSchemaWithExampleInQuery = Document.definitions['ParameterWithSchemaWithExampleInQuery']
-      ParameterWithSchemaWithExampleInHeader = Document.definitions['ParameterWithSchemaWithExampleInHeader']
-      ParameterWithSchemaWithExampleInCookie = Document.definitions['ParameterWithSchemaWithExampleInCookie']
-      ParameterWithSchemaWithExamples       = Document.definitions['ParameterWithSchemaWithExamples']
-      ParameterWithSchemaWithExamplesInPath = Document.definitions['ParameterWithSchemaWithExamplesInPath']
-      ParameterWithSchemaWithExamplesInQuery = Document.definitions['ParameterWithSchemaWithExamplesInQuery']
-      ParameterWithSchemaWithExamplesInHeader = Document.definitions['ParameterWithSchemaWithExamplesInHeader']
-      ParameterWithSchemaWithExamplesInCookie = Document.definitions['ParameterWithSchemaWithExamplesInCookie']
-      ParameterWithContent                   = Document.definitions['ParameterWithContent']
-      ParameterWithContentInPath            = Document.definitions['ParameterWithContentInPath']
-      ParameterWithContentNotInPath        = Document.definitions['ParameterWithContentNotInPath']
-      RequestBody                         = Document.definitions['RequestBody']
-      SecurityScheme                     = Document.definitions['SecurityScheme']
-      APIKeySecurityScheme              = Document.definitions['APIKeySecurityScheme']
-      HTTPSecurityScheme               = Document.definitions['HTTPSecurityScheme']
-      NonBearerHTTPSecurityScheme     = Document.definitions['NonBearerHTTPSecurityScheme']
-      BearerHTTPSecurityScheme       = Document.definitions['BearerHTTPSecurityScheme']
-      OAuth2SecurityScheme          = Document.definitions['OAuth2SecurityScheme']
-      OpenIdConnectSecurityScheme  = Document.definitions['OpenIdConnectSecurityScheme']
-      OAuthFlows                  = Document.definitions['OAuthFlows']
-      ImplicitOAuthFlow          = Document.definitions['ImplicitOAuthFlow']
-      PasswordOAuthFlow         = Document.definitions['PasswordOAuthFlow']
-      ClientCredentialsFlow     = Document.definitions['ClientCredentialsFlow']
-      AuthorizationCodeOAuthFlow = Document.definitions['AuthorizationCodeOAuthFlow']
-      Link                      = Document.definitions['Link']
-      LinkWithOperationRef     = Document.definitions['LinkWithOperationRef']
-      LinkWithOperationId     = Document.definitions['LinkWithOperationId']
-      Callback               = Document.definitions['Callback']
-      Encoding              = Document.definitions['Encoding']
-
-      raise(Bug) unless Schema < JSI::Schema
-      raise(Bug) unless SchemaReference < JSI::Schema
+    module Response
     end
-    module V2
-      openapi_document_schema = JSI.new_schema(::JSON.parse(Scorpio.root.join(
-        'documents/swagger.io/v2/schema.json'
-      ).read))
-
-      # the schema represented by Scorpio::OpenAPI::V2::Schema will describe schemas itself.
-      # JSI::Schema#describes_schema! enables this to implement the functionality of schemas.
-      describe_schema = [
-        openapi_document_schema.definitions['schema'],
-        # comments above on v3's definitions['Schema'].properties['additionalProperties'] apply here too
-        openapi_document_schema.definitions['schema'].properties['additionalProperties'],
-      ]
-      describe_schema.each { |s| s.describes_schema!([JSI::Schema::Draft04]) }
-
-      Document = openapi_document_schema.jsi_schema_module
-
-      # naming these is not strictly necessary, but is nice to have.
-      # generated: `puts Scorpio::OpenAPI::V2::Document.schema.definitions.keys.map { |k| "#{k[0].upcase}#{k[1..-1]} = Document.definitions['#{k}']" }`
-
-
-      Info            = Document.definitions['info']
-      Contact          = Document.definitions['contact']
-      License           = Document.definitions['license']
-      Paths              = Document.definitions['paths']
-      Definitions         = Document.definitions['definitions']
-      ParameterDefinitions = Document.definitions['parameterDefinitions']
-      ResponseDefinitions = Document.definitions['responseDefinitions']
-      ExternalDocs       = Document.definitions['externalDocs']
-      Examples          = Document.definitions['examples']
-      MimeType         = Document.definitions['mimeType']
-      Operation       = Document.definitions['operation']
-      PathItem         = Document.definitions['pathItem']
-      Responses         = Document.definitions['responses']
-      ResponseValue      = Document.definitions['responseValue']
-      Response            = Document.definitions['response']
-      Headers              = Document.definitions['headers']
-      Header                = Document.definitions['header']
-      VendorExtension        = Document.definitions['vendorExtension']
-      BodyParameter           = Document.definitions['bodyParameter']
-      HeaderParameterSubSchema = Document.definitions['headerParameterSubSchema']
-      QueryParameterSubSchema   = Document.definitions['queryParameterSubSchema']
-      FormDataParameterSubSchema = Document.definitions['formDataParameterSubSchema']
-      PathParameterSubSchema    = Document.definitions['pathParameterSubSchema']
-      NonBodyParameter         = Document.definitions['nonBodyParameter']
-      Parameter               = Document.definitions['parameter']
-      Schema                 = Document.definitions['schema']
-      FileSchema            = Document.definitions['fileSchema']
-      PrimitivesItems       = Document.definitions['primitivesItems']
-      Security               = Document.definitions['security']
-      SecurityRequirement     = Document.definitions['securityRequirement']
-      Xml                      = Document.definitions['xml']
-      Tag                       = Document.definitions['tag']
-      SecurityDefinitions        = Document.definitions['securityDefinitions']
-      BasicAuthenticationSecurity = Document.definitions['basicAuthenticationSecurity']
-      ApiKeySecurity             = Document.definitions['apiKeySecurity']
-      Oauth2ImplicitSecurity    = Document.definitions['oauth2ImplicitSecurity']
-      Oauth2PasswordSecurity   = Document.definitions['oauth2PasswordSecurity']
-      Oauth2ApplicationSecurity = Document.definitions['oauth2ApplicationSecurity']
-      Oauth2AccessCodeSecurity = Document.definitions['oauth2AccessCodeSecurity']
-      Oauth2Scopes            = Document.definitions['oauth2Scopes']
-      MediaTypeList          = Document.definitions['mediaTypeList']
-      ParametersList         = Document.definitions['parametersList']
-      SchemesList             = Document.definitions['schemesList']
-      CollectionFormat         = Document.definitions['collectionFormat']
-      CollectionFormatWithMulti = Document.definitions['collectionFormatWithMulti']
-      Title                    = Document.definitions['title']
-      Description             = Document.definitions['description']
-      Default                = Document.definitions['default']
-      MultipleOf            = Document.definitions['multipleOf']
-      Maximum              = Document.definitions['maximum']
-      ExclusiveMaximum    = Document.definitions['exclusiveMaximum']
-      Minimum            = Document.definitions['minimum']
-      ExclusiveMinimum  = Document.definitions['exclusiveMinimum']
-      MaxLength        = Document.definitions['maxLength']
-      MinLength       = Document.definitions['minLength']
-      Pattern        = Document.definitions['pattern']
-      MaxItems      = Document.definitions['maxItems']
-      MinItems     = Document.definitions['minItems']
-      UniqueItems = Document.definitions['uniqueItems']
-      Enum         = Document.definitions['enum']
-      JsonReference = Document.definitions['jsonReference']
 
-      raise(Bug) unless Schema < JSI::Schema
+    module Paths
     end
 
-    # the autoloads for OpenAPI::Operation and OpenAPI::Document are triggered below. these
-    # should not be triggered until all the classes their files reference are defined (above).
+    module PathItem
+    end
 
+    module SecurityScheme
+      include(Document::Descendent)
 
-    module V3
-      module Operation
-        include OpenAPI::Operation
-      end
-      module Document
-        include OpenAPI::Document
-      end
-      module Reference
-        include OpenAPI::Reference
+      # @return [Enumerable<OpenAPI::Operation>]
+      def operations
+        openapi_document.operations.select do |op|
+          op.security.respond_to?(:to_ary) && op.security.any? { |sr| sr.each_key.include?(propertyName) }
+        end
       end
-      module Tag
-        include OpenAPI::Tag
-      end
-      require 'scorpio/openapi/v3/server'
-    end
 
-    module V2
-      module Operation
-        include OpenAPI::Operation
-      end
-      module Document
-        include OpenAPI::Document
-      end
-      module JsonReference
-        include OpenAPI::Reference
-      end
-      module Tag
-        include OpenAPI::Tag
+      def propertyName
+        jsi_ptr.tokens.last
       end
     end
+
+    autoload(:V2, 'scorpio/openapi/v2')
+    autoload(:V3, 'scorpio/openapi/v3_0')
+    autoload(:V3_0, 'scorpio/openapi/v3_0')
+    autoload(:V3_1, 'scorpio/openapi/v3_1')
+
+    autoload(:SchemaElements, 'scorpio/openapi/schema_elements')
   end
 end

data/lib/scorpio/request.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 module Scorpio
+  # a Request from a {Scorpio::OpenAPI::Operation}.
+  # Used by {Scorpio::OpenAPI::Operation#build_request} and related methods.
   class Request
-    # media types for which Scorpio has implemented generating / parsing between body
-    # and body_object (see {Request#body} and {Response#body_object})
-    SUPPORTED_REQUEST_MEDIA_TYPES = %w(
+    # media types for which Scorpio has implemented generating {Request#body} from {Request#body_object}
+    SUPPORTED_MEDIA_TYPES = %w(
       application/json
       application/x-www-form-urlencoded
     ).map(&:freeze).freeze
 
     FALLBACK_CONTENT_TYPE = 'application/x-www-form-urlencoded'.freeze
 
+    DEFAULT_USER_AGENT = -"Scorpio/#{Scorpio::VERSION} (https://github.com/notEthan/scorpio) Faraday/#{Faraday::VERSION} Ruby/#{RUBY_VERSION}"
+
     # see also Faraday::Env::MethodsWithBodies
     METHODS_WITH_BODIES = %w(post put patch options).map(&:freeze).freeze
 
@@ -18,17 +21,10 @@ module Scorpio
       if media_types.size == 1
         media_types.first
       else
-        SUPPORTED_REQUEST_MEDIA_TYPES.detect { |mt| media_types.include?(mt) }
+        SUPPORTED_MEDIA_TYPES.detect { |mt| media_types.include?(mt) }
       end
     end
 
-    # @param http_method [String]
-    # @return [Boolean]
-    def self.method_with_body?(http_method)
-      raise(ArgumentError) unless http_method.is_a?(String)
-      METHODS_WITH_BODIES.include?(http_method.downcase)
-    end
-
     module Configurables
       attr_writer :path_params
       def path_params
@@ -66,6 +62,11 @@ module Scorpio
         operation.base_url(scheme: scheme, server: server, server_variables: server_variables)
       end
 
+      # overriding url will cause all of path_params, query_params, querystring, scheme, server, server_variables, and base_url to be ignored
+      def url=(url)
+        @url = JSI::Util.uri(url)
+      end
+
       attr_writer :body
       def body
         return @body if instance_variable_defined?(:@body)
@@ -75,13 +76,13 @@ module Scorpio
           elsif content_type && content_type.form_urlencoded?
             URI.encode_www_form(body_object)
 
-          # NOTE: the supported media types above should correspond to Request::SUPPORTED_REQUEST_MEDIA_TYPES
+          # NOTE: the supported media types above should correspond to Request::SUPPORTED_MEDIA_TYPES
 
           else
             if body_object.respond_to?(:to_str)
               body_object
             else
-              raise(NotImplementedError, "Scorpio does not know how to generate the request body with content_type = #{content_type.respond_to?(:to_str) ? content_type : content_type.inspect} for operation: #{operation.human_id}. Scorpio supports media types: #{SUPPORTED_REQUEST_MEDIA_TYPES.join(', ')}. body_object was: #{body_object.pretty_inspect.chomp}")
+              raise(NotImplementedError, -"Scorpio does not know how to generate the request body with content_type = #{content_type.respond_to?(:to_str) ? content_type : content_type.inspect} for operation: #{operation.human_id}. Scorpio supports media types: #{SUPPORTED_MEDIA_TYPES.join(', ')}. body_object was: #{body_object.pretty_inspect.chomp}")
             end
           end
         else
@@ -109,6 +110,18 @@ module Scorpio
         operation.user_agent
       end
 
+      attr_writer(:accept)
+      def accept
+        return @accept if instance_variable_defined?(:@accept)
+        operation.accept
+      end
+
+      attr_writer(:authorization)
+      def authorization
+        return @authorization if instance_variable_defined?(:@authorization)
+        operation.authorization
+      end
+
       attr_writer :faraday_builder
       def faraday_builder
         return @faraday_builder if instance_variable_defined?(:@faraday_builder)
@@ -129,35 +142,21 @@ module Scorpio
     end
     include Configurables
 
-    @request_class_by_operation = Hash.new do |h, op|
-      h[op] = Class.new(Request) do
-        define_method(:operation) { op }
-        include(op.request_accessor_module)
-      end
-    end
-
-    def self.request_class_by_operation(operation)
-      @request_class_by_operation[operation]
-    end
-
-    # @param configuration [#to_hash] a hash keyed with configurable attributes for
-    #   the request - instance methods of Scorpio::Request::Configurables, whose values
-    #   will be assigned for those attributes.
-    def initialize(configuration = {}, &b)
+    # @param configuration [#to_hash] A hash of configurable attributes or
+    #   parameters for the request - instance methods of
+    #   {Scorpio::Request::Configurables}, or request parameters defined by the
+    #   operation.
+    def initialize(operation, **configuration, &b)
+      @operation = operation
       configuration = JSI::Util.stringify_symbol_keys(configuration)
-      params_set = Set.new # the set of params that have been set
-      # do the Configurables first
       configuration.each do |name, value|
-        if Configurables.public_method_defined?("#{name}=")
-          Configurables.instance_method("#{name}=").bind(self).call(value)
-          params_set << name
+        if Configurables.public_method_defined?(:"#{name}=")
+          public_send(:"#{name}=", value)
+        else
+          param = param_for(name) || raise(ArgumentError, -"unrecognized configuration value passed: #{name.inspect}")
+          set_param_from(param['in'], param['name'], value)
         end
       end
-      # then do other top-level params
-      configuration.reject { |name, _| params_set.include?(name) }.each do |name, value|
-        param = param_for(name) || raise(ArgumentError, "unrecognized configuration value passed: #{name.inspect}")
-        set_param_from(param['in'], param['name'], value)
-      end
 
       if block_given?
         yield self
@@ -165,7 +164,7 @@ module Scorpio
     end
 
     # @return [Scorpio::OpenAPI::Operation]
-    attr_reader :operation
+    attr_reader(:operation)
 
     # @return [Scorpio::OpenAPI::Document]
     def openapi_document
@@ -178,6 +177,11 @@ module Scorpio
       operation.http_method
     end
 
+    # @return [Boolean]
+    def http_method_with_body?
+      METHODS_WITH_BODIES.include?(http_method.to_str.downcase)
+    end
+
     # the template for the request's path, to be expanded with {Configurables#path_params} and appended to
     # the request's {Configurables#base_url}
     # @return [Addressable::Template]
@@ -191,13 +195,11 @@ module Scorpio
       path_params = JSI::Util.stringify_symbol_keys(self.path_params)
       missing_variables = path_template.variables - path_params.keys
       if missing_variables.any?
-        raise(ArgumentError, "path #{operation.path_template_str} for operation #{operation.human_id} requires path_params " +
-          "which were missing: #{missing_variables.inspect}")
+        raise(ArgumentError, -"missing params: #{missing_variables.inspect}\nfor path: #{operation.path_template_str}\nfor operation: #{operation.human_id}")
       end
       empty_variables = path_template.variables.select { |v| path_params[v].to_s.empty? }
       if empty_variables.any?
-        raise(ArgumentError, "path #{operation.path_template_str} for operation #{operation.human_id} requires path_params " +
-          "which were empty: #{empty_variables.inspect}")
+        raise(ArgumentError, -"empty params: #{empty_variables.inspect}\sfor path: #{operation.path_template_str}\nfor operation #{operation.human_id}")
       end
 
       path = path_template.expand(path_params)
@@ -210,6 +212,7 @@ module Scorpio
     # the full URL for this request
     # @return [Addressable::URI]
     def url
+      return @url if instance_variable_defined?(:@url)
       unless base_url
         raise(ArgumentError, "no base_url has been specified for request")
       end
@@ -242,11 +245,11 @@ module Scorpio
     # builds a Faraday connection with this Request's faraday_builder and faraday_adapter.
     # passes a given proc yield_ur to middleware to yield an Ur for requests made with the connection.
     #
-    # @param yield_ur [Proc]
+    # @param yield_ur [Proc, nil]
     # @return [::Faraday::Connection]
     def faraday_connection(yield_ur = nil)
       Faraday.new do |faraday_connection|
-        faraday_builder.call(faraday_connection)
+        faraday_builder.call(faraday_connection) if faraday_builder
         if yield_ur
           -> { ::Ur::Faraday }.() # autoload trigger
 
@@ -289,7 +292,7 @@ module Scorpio
         nil
       else
         raise(AmbiguousParameter.new(
-          "There are multiple parameters for #{name}. matched parameters were: #{params.pretty_inspect.chomp}"
+          -"There are multiple parameters for #{name}. matched parameters were: #{params.pretty_inspect.chomp}"
         ).tap { |e| e.name = name })
       end
     end
@@ -299,15 +302,15 @@ module Scorpio
     # @raise [Scorpio::ParameterError] if no parameter has the given name
     # @raise (see #param_for)
     def param_for!(name)
-      param_for(name) || raise(ParameterError, "There is no parameter named #{name} on operation #{operation.human_id}:\n#{operation.pretty_inspect.chomp}")
+      param_for(name) || raise(ParameterError, -"There is no parameter named #{name} on operation #{operation.human_id}:\n#{operation.pretty_inspect.chomp}")
     end
 
-    # applies the named value to the appropriate parameter of the request
+    # Applies the given value to the appropriate parameter of the request
     # @param param_in [String, Symbol] one of 'path', 'query', 'header', or 'cookie' - where to apply
-    #   the named value
+    #   the given value
     # @param name [String, Symbol] the parameter name to apply the value to
-    # @param value [Object] the value
-    # @return [Object] echoes the value param
+    # @param value [Object] parameter value
+    # @return [Object] the given parameter value
     # @raise [ArgumentError] invalid `param_in` parameter
     # @raise [NotImplementedError] cookies aren't implemented
     def set_param_from(param_in, name, value)
@@ -318,11 +321,11 @@ module Scorpio
       elsif param_in == 'query'
         self.query_params = (self.query_params || {}).merge(name => value)
       elsif param_in == 'header'
-        self.headers = self.headers.merge(name => value)
+        self.headers = self.headers.merge(name => value.to_str)
       elsif param_in == 'cookie'
-        raise(NotImplementedError, "cookies not implemented: #{name.inspect} => #{value.inspect}")
+        raise(NotImplementedError, -"cookies not implemented: #{name.inspect} => #{value.inspect}")
       else
-        raise(ArgumentError, "cannot set param from param_in = #{param_in.inspect} (name: #{name.pretty_inspect.chomp}, value: #{value.pretty_inspect.chomp})")
+        raise(ArgumentError, -"cannot set param from param_in = #{param_in.inspect} (name: #{name.pretty_inspect.chomp}, value: #{value.pretty_inspect.chomp})")
       end
       value
     end
@@ -340,12 +343,12 @@ module Scorpio
       elsif param_in == 'query'
         query_params ? query_params[name] : nil
       elsif param_in == 'header'
-        _, value = headers.detect { |headername, _| headername.downcase == name.downcase }
+        _, value = headers.detect { |headername, _| headername.casecmp?(name) }
         value
       elsif param_in == 'cookie'
-        raise(NotImplementedError, "cookies not implemented: #{name.inspect}")
+        raise(NotImplementedError, -"cookies not implemented: #{name.inspect}")
       else
-        raise(OpenAPI::SemanticError, "cannot get param from param_in = #{param_in.inspect} (name: #{name.pretty_inspect.chomp})")
+        raise(OpenAPI::SemanticError, -"cannot get param from param_in = #{param_in.inspect} (name: #{name.pretty_inspect.chomp})")
       end
     end
 
@@ -357,6 +360,8 @@ module Scorpio
       if user_agent
         headers['User-Agent'] = user_agent
       end
+      headers['Accept'] = accept if accept
+      headers['Authorization'] = authorization if authorization
       if !content_type_header
         if media_type
           headers['Content-Type'] = media_type
@@ -382,12 +387,13 @@ module Scorpio
     # parsed according to an understood media type, and instantiated with the applicable
     # response schema if one is specified. see {Scorpio::Response#body_object} for more detail.
     #
+    # @param mutable (see Response#body_object)
     # @raise [Scorpio::HTTPError] if the request returns a 4xx or 5xx status, the appropriate
     #   error is raised - see {Scorpio::HTTPErrors}
-    def run
+    def run(mutable: false)
       ur = run_ur
       ur.raise_on_http_error
-      ur.response.body_object
+      ur.response.body_object(mutable: mutable)
     end
 
     # Runs this request, passing the resulting Ur to the given block.
@@ -407,8 +413,8 @@ module Scorpio
       while page_ur
         unless page_ur.is_a?(Scorpio::Ur)
           raise(TypeError, [
-            "next_page must result in a #{Scorpio::Ur}",
-            "this should be the result of #run_ur from a #{OpenAPI::Operation} or #{Request}",
+            -"next_page must result in a #{Scorpio::Ur}",
+            -"this should be the result of #run_ur from a #{OpenAPI::Operation} or #{Request}",
           ].join("\n"))
         end
         page_ur.raise_on_http_error if raise_on_http_error