Request.verb is now an upcased string (ex: "GET")

The reference for a request verb is now the string which is used
everywhere else, instead of the symbol corresponding to it. This was an
artifact from the import from httprb, and there is no advantage in it,
since these strings are frozen in most use cases, and the
transformations from symbol to strings being performed everywhere are
prooof that keeping the atom isn't really bringing any benefit.

integration_tests/datadog_test.rb

@@ -36,7 +36,7 @@ class DatadogTest < Minitest::Test
     set_datadog
     uri = URI(build_uri("/status/200", "http://#{httpbin}"))
 
-    get_response, post_response = HTTPX.request([[:get, uri], [:post, uri]])
+    get_response, post_response = HTTPX.request([["GET", uri], ["POST", uri]])
     verify_status(get_response, 200)
     verify_status(post_response, 200)
 

lib/httpx/adapters/datadog.rb

@@ -68,7 +68,7 @@ module TRACING_MODULE # rubocop:disable Naming/ClassAndModuleCamelCase
 
             @request.on(:response, &method(:finish))
 
-            verb = @request.verb.to_s.upcase
+            verb = @request.verb
             uri = @request.uri
 
             @span = build_span

lib/httpx/adapters/faraday.rb

@@ -44,7 +44,7 @@ module Faraday
             headers: env.request_headers,
             body: env.body,
           }
-          [meth, env.url, request_options]
+          [meth.to_s.upcase, env.url, request_options]
         end
 
         def options_from_env(env)

lib/httpx/adapters/sentry.rb

@@ -75,7 +75,7 @@ module HTTPX::Plugins
         uri = req.uri
 
         result = {
-          method: req.verb.to_s.upcase,
+          method: req.verb,
         }
 
         if ::Sentry.configuration.send_default_pii

lib/httpx/adapters/webmock.rb

@@ -23,7 +23,7 @@ module WebMock
           uri.path = uri.normalized_path.gsub("[^:]//", "/")
 
           WebMock::RequestSignature.new(
-            request.verb,
+            request.verb.downcase.to_sym,
             uri.to_s,
             body: request.body.each.to_a.join,
             headers: request.headers.to_h

lib/httpx/chainable.rb

@@ -2,11 +2,11 @@
 
 module HTTPX
   module Chainable
-    %i[head get post put delete trace options connect patch].each do |meth|
+    %w[head get post put delete trace options connect patch].each do |meth|
       class_eval(<<-MOD, __FILE__, __LINE__ + 1)
-        def #{meth}(*uri, **options)        # def get(*uri, **options)
-          request(:#{meth}, uri, **options) #   request(:get, uri, **options)
-        end                                 # end
+        def #{meth}(*uri, **options)                # def get(*uri, **options)
+          request("#{meth.upcase}", uri, **options) #   request("GET", uri, **options)
+        end                                         # end
       MOD
     end
 

lib/httpx/connection/http1.rb

@@ -312,7 +312,7 @@ module HTTPX
     end
 
     def join_headline(request)
-      "#{request.verb.to_s.upcase} #{request.path} HTTP/#{@version.join(".")}"
+      "#{request.verb} #{request.path} HTTP/#{@version.join(".")}"
     end
 
     def join_headers(request)

lib/httpx/connection/http2.rb

@@ -208,7 +208,7 @@ module HTTPX
     def set_protocol_headers(request)
       {
         ":scheme" => request.scheme,
-        ":method" => request.verb.to_s.upcase,
+        ":method" => request.verb,
         ":path" => request.path,
         ":authority" => request.authority,
       }

lib/httpx/plugins/authentication/digest.rb

@@ -21,7 +21,7 @@ module HTTPX
         end
 
         def authenticate(request, authenticate)
-          "Digest #{generate_header(request.verb.to_s.upcase, request.path, authenticate)}"
+          "Digest #{generate_header(request.verb, request.path, authenticate)}"
         end
 
         private

lib/httpx/plugins/aws_sigv4.rb

@@ -71,7 +71,7 @@ module HTTPX
           end.join
 
           # canonical request
-          creq = "#{request.verb.to_s.upcase}" \
+          creq = "#{request.verb}" \
                  "\n#{request.canonical_path}" \
                  "\n#{request.canonical_query}" \
                  "\n#{canonical_headers}" \

lib/httpx/plugins/follow_redirects.rb

@@ -103,7 +103,7 @@ module HTTPX
                                           max_redirects: max_redirects - 1)
           end
 
-          build_request(:get, redirect_uri, retry_options)
+          build_request("GET", redirect_uri, retry_options)
         end
 
         def __get_location_from_response(response)

lib/httpx/plugins/grpc.rb

@@ -264,7 +264,7 @@ module HTTPX
             Message.encode(input, deflater: deflater)
           end
 
-          build_request(:post, uri, headers: headers, body: body)
+          build_request("POST", uri, headers: headers, body: body)
         end
       end
     end

lib/httpx/plugins/h2c.rb

@@ -9,7 +9,7 @@ module HTTPX
     # https://gitlab.com/os85/httpx/wikis/Upgrade#h2c
     #
     module H2C
-      VALID_H2C_VERBS = %i[get options head].freeze
+      VALID_H2C_VERBS = %w[GET OPTIONS HEAD].freeze
 
       class << self
         def load_dependencies(*)

lib/httpx/plugins/proxy/http.rb

@@ -141,9 +141,9 @@ module HTTPX
 
         module ProxyParser
           def join_headline(request)
-            return super if request.verb == :connect
+            return super if request.verb == "CONNECT"
 
-            "#{request.verb.to_s.upcase} #{request.uri} HTTP/#{@version.join(".")}"
+            "#{request.verb} #{request.uri} HTTP/#{@version.join(".")}"
           end
 
           def set_protocol_headers(request)
@@ -161,7 +161,7 @@ module HTTPX
 
         class ConnectRequest < Request
           def initialize(uri, _options)
-            super(:connect, uri, {})
+            super("CONNECT", uri, {})
             @headers.delete("accept")
           end
 

lib/httpx/plugins/response_cache.rb

@@ -8,7 +8,7 @@ module HTTPX
     # https://gitlab.com/os85/httpx/wikis/Response-Cache
     #
     module ResponseCache
-      CACHEABLE_VERBS = %i[get head].freeze
+      CACHEABLE_VERBS = %w[GET HEAD].freeze
       CACHEABLE_STATUS_CODES = [200, 203, 206, 300, 301, 410].freeze
       private_constant :CACHEABLE_VERBS
       private_constant :CACHEABLE_STATUS_CODES
@@ -96,7 +96,7 @@ module HTTPX
 
       module RequestMethods
         def response_cache_key
-          @response_cache_key ||= Digest::SHA1.hexdigest("httpx-response-cache-#{@verb}#{@uri}")
+          @response_cache_key ||= Digest::SHA1.hexdigest("httpx-response-cache-#{@verb}-#{@uri}")
         end
       end
 

lib/httpx/plugins/retries.rb

@@ -11,7 +11,7 @@ module HTTPX
       MAX_RETRIES = 3
       # TODO: pass max_retries in a configure/load block
 
-      IDEMPOTENT_METHODS = %i[get options head put delete].freeze
+      IDEMPOTENT_METHODS = %w[GET OPTIONS HEAD PUT DELETE].freeze
       RETRYABLE_ERRORS = [
         IOError,
         EOFError,

lib/httpx/plugins/webdav.rb

@@ -10,11 +10,11 @@ module HTTPX
     module WebDav
       module InstanceMethods
         def copy(src, dest)
-          request(:copy, src, headers: { "destination" => @options.origin.merge(dest) })
+          request("COPY", src, headers: { "destination" => @options.origin.merge(dest) })
         end
 
         def move(src, dest)
-          request(:move, src, headers: { "destination" => @options.origin.merge(dest) })
+          request("MOVE", src, headers: { "destination" => @options.origin.merge(dest) })
         end
 
         def lock(path, timeout: nil, &blk)
@@ -30,7 +30,7 @@ module HTTPX
                 "<D:locktype><D:write/></D:locktype>" \
                 "<D:owner>null</D:owner>" \
                 "</D:lockinfo>"
-          response = request(:lock, path, headers: headers, xml: xml)
+          response = request("LOCK", path, headers: headers, xml: xml)
 
           return response unless response.is_a?(Response)
 
@@ -46,11 +46,11 @@ module HTTPX
         end
 
         def unlock(path, lock_token)
-          request(:unlock, path, headers: { "lock-token" => lock_token })
+          request("UNLOCK", path, headers: { "lock-token" => lock_token })
         end
 
         def mkcol(dir)
-          request(:mkcol, dir)
+          request("MKCOL", dir)
         end
 
         def propfind(path, xml = nil)
@@ -64,13 +64,13 @@ module HTTPX
                    xml
           end
 
-          request(:propfind, path, headers: { "depth" => "1" }, xml: body)
+          request("PROPFIND", path, headers: { "depth" => "1" }, xml: body)
         end
 
         def proppatch(path, xml)
           body = "<?xml version=\"1.0\"?>" \
                  "<D:propertyupdate xmlns:D=\"DAV:\" xmlns:Z=\"http://ns.example.com/standards/z39.50/\">#{xml}</D:propertyupdate>"
-          request(:proppatch, path, xml: body)
+          request("PROPPATCH", path, xml: body)
         end
         # %i[ orderpatch acl report search]
       end

lib/httpx/request.rb

@@ -19,7 +19,11 @@ module HTTPX
     def_delegator :@body, :empty?
 
     def initialize(verb, uri, options = {})
-      @verb    = verb.to_s.downcase.to_sym
+      if verb.is_a?(Symbol)
+        warn "DEPRECATION WARNING: Using symbols for `verb` is deprecated, and will not be supported in httpx 1.0. " \
+             "Use \"#{verb.to_s.upcase}\" instead."
+      end
+      @verb    = verb.to_s.upcase
       @options = Options.new(options)
       @uri     = Utils.to_uri(uri)
       if @uri.relative?
@@ -138,7 +142,7 @@ module HTTPX
     # :nocov:
     def inspect
       "#<HTTPX::Request:#{object_id} " \
-        "#{@verb.to_s.upcase} " \
+        "#{@verb} " \
         "#{uri} " \
         "@headers=#{@headers} " \
         "@body=#{@body}>"

lib/httpx/response.rb

@@ -56,12 +56,12 @@ module HTTPX
     end
 
     def bodyless?
-      @request.verb == :head ||
+      @request.verb == "HEAD" ||
         no_data?
     end
 
     def complete?
-      bodyless? || (@request.verb == :connect && @status == 200)
+      bodyless? || (@request.verb == "CONNECT" && @status == 200)
     end
 
     # :nocov:

regression_tests/bug_0_14_5_test.rb

@@ -13,7 +13,7 @@ class Bug_0_14_5_Test < Minitest::Test
       http.get("https://#{httpbin}/get")
 
       requests = 2.times.map do
-        http.build_request(:post, post_uri, body: "a" * (1 << 16)) # 65k body, must be above write buffer size
+        http.build_request("POST", post_uri, body: "a" * (1 << 16)) # 65k body, must be above write buffer size
       end
 
       responses = http.request(*requests)

sig/chainable.rbs

@@ -2,9 +2,9 @@ module HTTPX
   module Chainable
     def request: (*Request, **untyped) -> Array[response]
                | (Request, **untyped) -> response
-               | (verb | string, uri | [uri], **untyped) -> response
-               | (Array[[verb | string, uri] | [verb | string, uri, options]], **untyped) -> Array[response]
-               | (verb | string, _Each[uri | [uri, options]], **untyped) -> Array[response]
+               | (verb, uri | [uri], **untyped) -> response
+               | (Array[[verb, uri] | [verb, uri, options]], **untyped) -> Array[response]
+               | (verb, _Each[uri | [uri, options]], **untyped) -> Array[response]
 
     def accept: (String) -> Session
     def wrap: () { (Session) -> void } -> void

sig/httpx.rbs

@@ -8,9 +8,9 @@ module HTTPX
   type uri = URI::HTTP | URI::HTTPS | string
   type generic_uri = String | URI::Generic
 
-  type verb = :options | :get | :head | :post | :put | :delete | :trace | :connect |
-              :propfind | :proppatch | :mkcol | :copy | :move | :lock | :unlock | :orderpatch |
-              :acl | :report | :patch | :search
+  type verb = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" |
+              "PROPFIND" | "PROPPATCH" | "MKCOL" | "COPY" | "MOVE" | "LOCK" | "UNLOCK" | "ORDERPATCH" |
+              "ACL" | "REPORT" | "PATCH" | "SEARCH"
 
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 

sig/plugins/h2c.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   module Plugins
     module H2C
-      VALID_H2C_VERBS: Array[Symbol]
+      VALID_H2C_VERBS: Array[verb]
 
       def self.load_dependencies: (*untyped) -> void
       def self.configure: (singleton(Session)) -> void

sig/plugins/response_cache.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   module Plugins
     module ResponseCache
-      CACHEABLE_VERBS: Array[Symbol]
+      CACHEABLE_VERBS: Array[verb]
 
       def self?.cacheable_request?: (Request request) -> bool
       def self?.cacheable_response?: (response response) -> bool

sig/request.rbs

@@ -6,7 +6,7 @@ module HTTPX
     METHODS: Array[Symbol]
     USER_AGENT: String
 
-    attr_reader verb: Symbol
+    attr_reader verb: verb
     attr_reader uri: URI::Generic
     attr_reader headers: Headers
     attr_reader body: Body

sig/session.rbs

@@ -17,7 +17,7 @@ module HTTPX
 
     def close: (*untyped) -> void
 
-    def build_request: (String | verb, generic_uri, ?options) -> Request
+    def build_request: (verb, generic_uri, ?options) -> Request
 
     private
 
@@ -35,11 +35,11 @@ module HTTPX
 
     def build_altsvc_connection: (Connection existing_connection, Array[Connection] connections, URI::Generic alt_origin, String origin, Hash[String, String] alt_params, Options options) -> Connection?
 
-    def build_requests: (verb | string, uri, options) -> Array[Request]
-                      | (Array[[verb | string, uri, options]], options) -> Array[Request]
-                      | (Array[[verb | string, uri]], options) -> Array[Request]
-                      | (verb | string, _Each[[uri, options]], Options) -> Array[Request]
-                      | (verb | string, _Each[uri], options) -> Array[Request]
+    def build_requests: (verb, uri, options) -> Array[Request]
+                      | (Array[[verb, uri, options]], options) -> Array[Request]
+                      | (Array[[verb, uri]], options) -> Array[Request]
+                      | (verb, _Each[[uri, options]], Options) -> Array[Request]
+                      | (verb, _Each[uri], options) -> Array[Request]
 
     def build_connection: (URI::Generic, Options) -> Connection
 

standalone_tests/response_json_multi_json_test.rb

@@ -17,7 +17,7 @@ class ResponseYajlTest < Minitest::Test
 
   private
 
-  def request(verb = :get, uri = "http://google.com")
+  def request(verb = "GET", uri = "http://google.com")
     Request.new(verb, uri)
   end
 

standalone_tests/response_json_oj_test.rb

@@ -17,7 +17,7 @@ class ResponseOjTest < Minitest::Test
 
   private
 
-  def request(verb = :get, uri = "http://google.com")
+  def request(verb = "GET", uri = "http://google.com")
     Request.new(verb, uri)
   end
 

standalone_tests/response_json_yajl_test.rb

@@ -17,7 +17,7 @@ class ResponseYajlTest < Minitest::Test
 
   private
 
-  def request(verb = :get, uri = "http://google.com")
+  def request(verb = "GET", uri = "http://google.com")
     Request.new(verb, uri)
   end
 

test/altsvc_test.rb

@@ -56,7 +56,7 @@ class AltSvcTest < Minitest::Test
     entries = AltSvc.cached_altsvc("http://www.example-clear-cache.com")
     assert !entries.empty?
 
-    req = Request.new(:get, "http://www.example-clear-cache.com/")
+    req = Request.new("GET", "http://www.example-clear-cache.com/")
     res = Response.new(req, 200, "2.0", { "alt-svc" => "clear" })
 
     AltSvc.emit(req, res)

test/aws_sigv4_test.rb

@@ -6,18 +6,18 @@ class HTTPXAwsSigv4Test < Minitest::Test
   include ResponseHelpers
 
   def test_plugin_aws_sigv4_canonical_query
-    r1 = sigv4_session.build_request(:get, "http://domain.com?b=c&a=b")
+    r1 = sigv4_session.build_request("GET", "http://domain.com?b=c&a=b")
     assert r1.canonical_query == "a=b&b=c"
-    r2 = sigv4_session.build_request(:get, "http://domain.com?a=c&a=b")
+    r2 = sigv4_session.build_request("GET", "http://domain.com?a=c&a=b")
     assert r2.canonical_query == "a=b&a=c"
-    r3 = sigv4_session.build_request(:get, "http://domain.com?a=b&a=b")
+    r3 = sigv4_session.build_request("GET", "http://domain.com?a=b&a=b")
     assert r3.canonical_query == "a=b&a=b"
-    r4 = sigv4_session.build_request(:get, "http://domain.com?b&a=b")
+    r4 = sigv4_session.build_request("GET", "http://domain.com?b&a=b")
     assert r4.canonical_query == "a=b&b"
   end
 
   def test_plugin_aws_sigv4_x_amz_date
-    request = sigv4_session.build_request(:get, "http://domain.com")
+    request = sigv4_session.build_request("GET", "http://domain.com")
     # x-amz-date
     assert request.headers.key?("x-amz-date")
     amz_date = Time.parse(request.headers["x-amz-date"])
@@ -26,35 +26,35 @@ class HTTPXAwsSigv4Test < Minitest::Test
     # date already set
     date = Time.now.utc - (60 * 60 * 24)
     date_amz = date.strftime("%Y%m%dT%H%M%SZ")
-    x_date_request = sigv4_session.build_request(:get, "http://domain.com", headers: { "x-amz-date" => date_amz })
+    x_date_request = sigv4_session.build_request("GET", "http://domain.com", headers: { "x-amz-date" => date_amz })
     verify_header(x_date_request.headers, "x-amz-date", date_amz)
   end
 
   def test_plugin_aws_sigv4_x_amz_security_token
-    request = sigv4_session.build_request(:get, "http://domain.com")
+    request = sigv4_session.build_request("GET", "http://domain.com")
     assert !request.headers.key?("x-amz-security-token")
 
-    tk_request = sigv4_session(security_token: "token").build_request(:get, "http://domain.com")
+    tk_request = sigv4_session(security_token: "token").build_request("GET", "http://domain.com")
     assert tk_request.headers.key?("x-amz-security-token")
     verify_header(tk_request.headers, "x-amz-security-token", "token")
 
     # already set
-    token_request = sigv4_session(security_token: "token").build_request(:get, "http://domain.com",
+    token_request = sigv4_session(security_token: "token").build_request("GET", "http://domain.com",
                                                                          headers: { "x-amz-security-token" => "TOKEN" })
     verify_header(token_request.headers, "x-amz-security-token", "TOKEN")
   end
 
   def test_plugin_aws_sigv4_x_amz_content_sha256
-    request = sigv4_session.build_request(:get, "http://domain.com", body: "abcd")
+    request = sigv4_session.build_request("GET", "http://domain.com", body: "abcd")
     assert request.headers["x-amz-content-sha256"] == Digest::SHA256.hexdigest("abcd")
 
     # already set
-    hashed_request = sigv4_session.build_request(:get, "http://domain.com", headers: { "x-amz-content-sha256" => "HASH" })
+    hashed_request = sigv4_session.build_request("GET", "http://domain.com", headers: { "x-amz-content-sha256" => "HASH" })
     verify_header(hashed_request.headers, "x-amz-content-sha256", "HASH")
   end
 
   def test_plugin_aws_sigv4_x_amz_content_sha256_stringio
-    request = sigv4_session.build_request(:get, "http://domain.com", body: StringIO.new("abcd"))
+    request = sigv4_session.build_request("GET", "http://domain.com", body: StringIO.new("abcd"))
     assert request.headers["x-amz-content-sha256"] == Digest::SHA256.hexdigest("abcd")
   end
 
@@ -63,7 +63,7 @@ class HTTPXAwsSigv4Test < Minitest::Test
     body.write("abcd")
     body.flush
 
-    request = sigv4_session.build_request(:get, "http://domain.com", body: body)
+    request = sigv4_session.build_request("GET", "http://domain.com", body: body)
     assert request.headers["x-amz-content-sha256"] == Digest::SHA256.hexdigest("abcd")
   ensure
     if body
@@ -78,7 +78,7 @@ class HTTPXAwsSigv4Test < Minitest::Test
       region: "REGION",
       unsigned_headers: %w[accept-encoding accept user-agent content-type content-length]
     ).build_request(
-      :put,
+      "PUT",
       "http://domain.com",
       headers: {
         "Host" => "domain.com",

test/error_response_test.rb

@@ -31,6 +31,6 @@ class ErrorResponseTest < Minitest::Test
   private
 
   def request_mock
-    Request.new(:get, "http://example.com/")
+    Request.new("GET", "http://example.com/")
   end
 end

test/https_test.rb

@@ -119,7 +119,7 @@ class HTTPSTest < Minitest::Test
       HTTPX.wrap do |http|
         total_time = start_time = nil
         trailered = false
-        request = http.build_request(:post, uri, body: %w[this is chunked])
+        request = http.build_request("POST", uri, body: %w[this is chunked])
         request.on(:headers) do |_written_request|
           start_time = HTTPX::Utils.now
         end

test/parser_test.rb

@@ -32,7 +32,7 @@ class HTTP1ParserTest < Minitest::Test
     private
 
     def mock_request
-      Request.new(:get, "http://google.com")
+      Request.new("GET", "http://google.com")
     end
   end
 

test/request_test.rb

@@ -6,15 +6,15 @@ class RequestTest < Minitest::Test
   include HTTPX
 
   def test_request_unsupported_body
-    ex = assert_raises(HTTPX::Error) { Request.new(:post, "http://example.com/", body: Object.new) }
+    ex = assert_raises(HTTPX::Error) { Request.new("POST", "http://example.com/", body: Object.new) }
     assert ex.message.include?("cannot determine size of body")
   end
 
   def test_request_verb
-    r1 = Request.new(:get, "http://example.com/")
-    assert r1.verb == :get, "unexpected verb (#{r1.verb})"
+    r1 = Request.new("GET", "http://example.com/")
+    assert r1.verb == "GET", "unexpected verb (#{r1.verb})"
     r2 = Request.new("GET", "http://example.com/")
-    assert r2.verb == :get, "unexpected verb (#{r1.verb})"
+    assert r2.verb == "GET", "unexpected verb (#{r1.verb})"
   end
 
   def test_request_headers
@@ -22,63 +22,63 @@ class RequestTest < Minitest::Test
   end
 
   def test_request_scheme
-    r1 = Request.new(:get, "http://google.com/path")
+    r1 = Request.new("GET", "http://google.com/path")
     assert r1.scheme == "http", "unexpected scheme (#{r1.scheme}"
-    r2 = Request.new(:get, "https://google.com/path")
+    r2 = Request.new("GET", "https://google.com/path")
     assert r2.scheme == "https", "unexpected scheme (#{r2.scheme}"
   end
 
   def test_request_authority
-    r1 = Request.new(:get, "http://google.com/path")
+    r1 = Request.new("GET", "http://google.com/path")
     assert r1.authority == "google.com", "unexpected authority (#{r1.authority})"
-    r2 = Request.new(:get, "http://google.com:80/path")
+    r2 = Request.new("GET", "http://google.com:80/path")
     assert r2.authority == "google.com", "unexpected authority (#{r2.authority})"
-    r3 = Request.new(:get, "http://app.dev:8080/path")
+    r3 = Request.new("GET", "http://app.dev:8080/path")
     assert r3.authority == "app.dev:8080", "unexpected authority (#{r3.authority})"
-    r4 = Request.new(:get, "http://127.0.0.1:80/path")
+    r4 = Request.new("GET", "http://127.0.0.1:80/path")
     assert r4.authority == "127.0.0.1", "unexpected authority (#{r4.authority})"
-    r5 = Request.new(:get, "https://[::1]:443/path")
+    r5 = Request.new("GET", "https://[::1]:443/path")
     assert r5.authority == "[::1]", "unexpected authority (#{r5.authority})"
-    r6 = Request.new(:get, "http://127.0.0.1:81/path")
+    r6 = Request.new("GET", "http://127.0.0.1:81/path")
     assert r6.authority == "127.0.0.1:81", "unexpected authority (#{r6.authority})"
-    r7 = Request.new(:get, "https://[::1]:444/path")
+    r7 = Request.new("GET", "https://[::1]:444/path")
     assert r7.authority == "[::1]:444", "unexpected authority (#{r7.authority})"
   end
 
   def test_request_path
-    r1 = Request.new(:get, "http://google.com/")
+    r1 = Request.new("GET", "http://google.com/")
     assert r1.path == "/", "unexpected path (#{r1.path})"
-    r2 = Request.new(:get, "http://google.com/path")
+    r2 = Request.new("GET", "http://google.com/path")
     assert r2.path == "/path", "unexpected path (#{r2.path})"
-    r3 = Request.new(:get, "http://google.com/path?q=bang&region=eu-west-1")
+    r3 = Request.new("GET", "http://google.com/path?q=bang&region=eu-west-1")
     assert r3.path == "/path?q=bang&region=eu-west-1", "unexpected path (#{r3.path})"
-    r4 = Request.new(:get, "https://google.com?q=bang bang")
+    r4 = Request.new("GET", "https://google.com?q=bang bang")
     assert r4.path == "/?q=bang%20bang", "must replace unsafe characters"
   end
 
   def test_request_body_raw
-    req = Request.new(:post, "http://example.com/", body: "bang")
+    req = Request.new("POST", "http://example.com/", body: "bang")
     assert !req.body.empty?, "body should exist"
     assert req.headers["content-type"] == "application/octet-stream", "content type is wrong"
     assert req.headers["content-length"] == "4", "content length is wrong"
   end
 
   def test_request_body_form
-    req = Request.new(:post, "http://example.com/", form: { "foo" => "bar" })
+    req = Request.new("POST", "http://example.com/", form: { "foo" => "bar" })
     assert !req.body.empty?, "body should exist"
     assert req.headers["content-type"] == "application/x-www-form-urlencoded", "content type is wrong"
     assert req.headers["content-length"] == "7", "content length is wrong"
   end
 
   def test_request_body_json
-    req = Request.new(:post, "http://example.com/", json: { "foo" => "bar" })
+    req = Request.new("POST", "http://example.com/", json: { "foo" => "bar" })
     assert !req.body.empty?, "body should exist"
     assert req.headers["content-type"] == "application/json; charset=utf-8", "content type is wrong"
     assert req.headers["content-length"] == "13", "content length is wrong"
   end
 
   def test_request_body_xml
-    req = Request.new(:post, "http://example.com/", xml: "<xml></xml>")
+    req = Request.new("POST", "http://example.com/", xml: "<xml></xml>")
     assert !req.body.empty?, "body should exist"
     assert req.headers["content-type"] == "application/xml; charset=utf-8", "content type is wrong"
     assert req.headers["content-length"] == "11", "content length is wrong"
@@ -87,6 +87,6 @@ class RequestTest < Minitest::Test
   private
 
   def resource
-    @resource ||= Request.new(:get, "http://localhost:3000")
+    @resource ||= Request.new("GET", "http://localhost:3000")
   end
 end

test/response_cache_store_test.rb

@@ -7,21 +7,21 @@ class ResponseCacheStoreTest < Minitest::Test
   include HTTPX
 
   def test_store_cache
-    request = request_class.new(:get, "http://example.com/")
+    request = request_class.new("GET", "http://example.com/")
     response = cached_response(request)
 
     assert store.lookup(request) == response
     assert store.cached?(request)
 
-    request2 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain" })
+    request2 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
     assert store.lookup(request2) == response
 
-    request3 = request_class.new(:post, "http://example.com/", headers: { "accept" => "text/plain" })
+    request3 = request_class.new("POST", "http://example.com/", headers: { "accept" => "text/plain" })
     assert store.lookup(request3).nil?
   end
 
   def test_store_error_status
-    request = request_class.new(:get, "http://example.com/")
+    request = request_class.new("GET", "http://example.com/")
     _response = cached_response(request, status: 404)
     assert !store.cached?(request)
 
@@ -30,61 +30,61 @@ class ResponseCacheStoreTest < Minitest::Test
   end
 
   def test_store_no_store
-    request = request_class.new(:get, "http://example.com/")
+    request = request_class.new("GET", "http://example.com/")
     _response = cached_response(request, extra_headers: { "cache-control" => "private, no-store" })
     assert !store.cached?(request)
   end
 
   def test_store_maxage
-    request = request_class.new(:get, "http://example.com/")
+    request = request_class.new("GET", "http://example.com/")
     response = cached_response(request, extra_headers: { "cache-control" => "max-age=2" })
     assert store.lookup(request) == response
     sleep(3)
     assert store.lookup(request).nil?
 
-    request2 = request_class.new(:get, "http://example2.com/")
+    request2 = request_class.new("GET", "http://example2.com/")
     _response2 = cached_response(request2, extra_headers: { "cache-control" => "no-cache, max-age=2" })
     assert store.lookup(request2).nil?
   end
 
   def test_store_expires
-    request = request_class.new(:get, "http://example.com/")
+    request = request_class.new("GET", "http://example.com/")
     response = cached_response(request, extra_headers: { "expires" => (Time.now + 2).httpdate })
     assert store.lookup(request) == response
     sleep(3)
     assert store.lookup(request).nil?
 
-    request2 = request_class.new(:get, "http://example2.com/")
+    request2 = request_class.new("GET", "http://example2.com/")
     _response2 = cached_response(request2, extra_headers: { "cache-control" => "no-cache", "expires" => (Time.now + 2).httpdate })
     assert store.lookup(request2).nil?
   end
 
   def test_prepare_vary
-    request = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain" })
+    request = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
     cached_response(request, extra_headers: { "vary" => "Accept" })
 
-    request2 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/html" })
+    request2 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/html" })
     store.prepare(request2)
     assert !request2.headers.key?("if-none-match")
-    request3 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain" })
+    request3 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
     store.prepare(request3)
     assert request3.headers.key?("if-none-match")
-    request4 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
+    request4 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
     store.prepare(request4)
     assert request4.headers.key?("if-none-match")
   end
 
   def test_prepare_vary_asterisk
-    request = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain" })
+    request = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
     cached_response(request, extra_headers: { "vary" => "*" })
 
-    request2 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/html" })
+    request2 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/html" })
     store.prepare(request2)
     assert !request2.headers.key?("if-none-match")
-    request3 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain" })
+    request3 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain" })
     store.prepare(request3)
     assert request3.headers.key?("if-none-match")
-    request4 = request_class.new(:get, "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
+    request4 = request_class.new("GET", "http://example.com/", headers: { "accept" => "text/plain", "user-agent" => "Linux Bowser" })
     store.prepare(request4)
     assert !request4.headers.key?("if-none-match")
   end

test/response_test.rb

@@ -65,7 +65,7 @@ class ResponseTest < Minitest::Test
     body2.write("bar")
     assert body2 == "foobar", "body buffers chunks"
 
-    body3 = Response::Body.new(Response.new(request("head"), 200, "2.0", {}), Options.new(body_threshold_size: 1024))
+    body3 = Response::Body.new(Response.new(request("HEAD"), 200, "2.0", {}), Options.new(body_threshold_size: 1024))
     assert body3.empty?, "body must be empty after initialization"
     assert body3 == "", "HEAD request body must be empty (#{body3})"
 
@@ -212,7 +212,7 @@ class ResponseTest < Minitest::Test
 
   private
 
-  def request(verb = :get, uri = "http://google.com")
+  def request(verb = "GET", uri = "http://google.com")
     Request.new(verb, uri)
   end
 

test/session_test.rb

@@ -26,7 +26,7 @@ class SessionTest < Minitest::Test
     assert session.options.respond_to?(:foo), "options methods weren't added"
     assert session.options.foo == "options-foo", "option method is unexpected"
 
-    request = session.options.request_class.new(:get, "http://example.com/", session.options)
+    request = session.options.request_class.new("GET", "http://example.com/", session.options)
     assert request.respond_to?(:foo), "request methods haven't been added"
     assert request.foo == "request-foo", "request method is unexpected"
     assert request.headers.respond_to?(:foo), "headers methods haven't been added"

test/support/requests/get.rb

@@ -30,7 +30,7 @@ module Requests
 
     def test_http_request
       uri = build_uri("/get")
-      response = HTTPX.request(:get, uri)
+      response = HTTPX.request("GET", uri)
       verify_status(response, 200)
       verify_body_length(response)
     end
@@ -38,7 +38,7 @@ module Requests
     def test_http_get_build_request
       uri = build_uri("/get")
       HTTPX.wrap do |http|
-        request = http.build_request(:get, uri)
+        request = http.build_request("GET", uri)
         response = http.request(request)
         verify_status(response, 200)
         verify_body_length(response)

test/support/requests/plugins/expect.rb

@@ -26,7 +26,7 @@ module Requests
           assert body == "echo: helloworld"
           verify_header(response.instance_variable_get(:@request).headers, "expect", "100-continue")
 
-          next_request = http.build_request(:post, build_uri("/", server.origin), body: "helloworld")
+          next_request = http.build_request("POST", build_uri("/", server.origin), body: "helloworld")
           verify_header(next_request.headers, "expect", "100-continue")
         end
       end
@@ -58,7 +58,7 @@ module Requests
           assert body == "echo: helloworld"
           verify_no_header(response.instance_variable_get(:@request).headers, "expect")
 
-          next_request = http.build_request(:post, build_uri("/", server.origin), body: "helloworld")
+          next_request = http.build_request("POST", build_uri("/", server.origin), body: "helloworld")
           verify_no_header(next_request.headers, "expect")
         end
       end

test/support/requests/plugins/h2c.rb

@@ -7,8 +7,8 @@ module Requests
         HTTPX.plugin(SessionWithPool).plugin(:h2c).wrap do |session|
           uri = build_uri("/get")
 
-          request = session.build_request(:get, uri)
-          request2 = session.build_request(:get, uri)
+          request = session.build_request("GET", uri)
+          request2 = session.build_request("GET", uri)
           response = session.request(request)
           verify_status(response, 200)
           assert response.version == "2.0", "http h2c requests should be in HTTP/2"

test/support/requests/plugins/multipart.rb

@@ -225,7 +225,7 @@ module Requests
                              .class.default_options
                              .response_class
                              .new(
-                               HTTPX::Request.new(:get, "http://example.com"),
+                               HTTPX::Request.new("GET", "http://example.com"),
                                200,
                                "2.0",
                                { "content-type" => "multipart/form-data; boundary=90" }

test/support/requests/plugins/upgrade.rb

@@ -15,8 +15,8 @@ module Requests
         http.plugin(:upgrade).wrap do |session|
           uri = build_uri("/", "https://stadtschreiber.ruhr")
 
-          request = session.build_request(:get, uri)
-          request2 = session.build_request(:get, uri)
+          request = session.build_request("GET", uri)
+          request2 = session.build_request("GET", uri)
 
           response = session.request(request)
           verify_status(response, 200)

test/support/requests/with_body.rb

@@ -106,8 +106,8 @@ module Requests
       define_method :"test_#{meth}_multiple_params" do
         uri = build_uri("/#{meth}")
         response1, response2 = HTTPX.request([
-                                               [meth, uri, { body: "data" }],
-                                               [meth, uri, { form: { "foo" => "bar" } }],
+                                               [meth.upcase, uri, { body: "data" }],
+                                               [meth.upcase, uri, { form: { "foo" => "bar" } }],
                                              ], max_concurrent_requests: 1) # because httpbin sucks and can't handle pipeline requests
 
         verify_status(response1, 200)
@@ -124,7 +124,7 @@ module Requests
       define_method :"test_#{meth}_build_request_body_params" do
         uri = build_uri("/#{meth}")
         HTTPX.wrap do |http|
-          request = http.build_request(meth, uri, body: "data")
+          request = http.build_request(meth.upcase, uri, body: "data")
           response = http.request(request)
           verify_status(response, 200)
           body = json_body(response)

test/support/requests/with_chunked_body.rb

@@ -22,7 +22,7 @@ module Requests
 
         total_time = start_time = nil
         trailered = false
-        request = http.build_request(meth, uri, headers: { "trailer" => "X-Time-Spent" }, body: %w[this is a chunked response])
+        request = http.build_request(meth.upcase, uri, headers: { "trailer" => "X-Time-Spent" }, body: %w[this is a chunked response])
         request.on(:headers) do |_written_request|
           start_time = HTTPX::Utils.now
         end