Convert test suite from Minitest::Spec DSL to Minitest::Test

Author: sferik

.rubocop.yml

@@ -19,3 +19,15 @@ Lint/MissingSuper:
   AllowedParentClasses:
     - BasicObject
     - Feature
+
+Minitest/MultipleAssertions:
+  Exclude:
+    - 'test/**/*.rb'
+
+Minitest/TestFileName:
+  Exclude:
+    - 'test/regression_tests.rb'
+
+Naming/VariableNumber:
+  Exclude:
+    - 'test/**/*.rb'

.rubocop/metrics.yml

@@ -1,6 +1,6 @@
 Metrics/AbcSize:
   Exclude:
-    - 'test/support/**/*.rb'
+    - 'test/**/*.rb'
 
 Metrics/ParameterLists:
   CountKeywordArgs: false
@@ -20,20 +20,20 @@ Metrics/ClassLength:
     - heredoc
     - method_call
   Exclude:
-    - 'test/support/**/*.rb'
+    - 'test/**/*.rb'
 
 Metrics/MethodLength:
   CountAsOne:
     - array
     - heredoc
     - method_call
   Exclude:
-    - 'test/support/**/*.rb'
+    - 'test/**/*.rb'
 
 Metrics/ModuleLength:
   CountAsOne:
     - array
     - heredoc
     - method_call
   Exclude:
-    - 'test/support/**/*.rb'
+    - 'test/**/*.rb'

.rubocop/style.yml

@@ -14,6 +14,11 @@ Style/OneClassPerFile:
   Exclude:
     - 'test/**/*.rb'
 
+Style/RescueModifier:
+  Exclude:
+    - 'test/support/dummy_server.rb'
+    - 'test/support/proxy_server.rb'
+
 Style/RescueStandardError:
   Enabled: true
   EnforcedStyle: implicit

lib/http/features/digest_auth.rb

@@ -123,14 +123,16 @@ def build_auth(request, challenge)
         ha1 = compute_ha1(algorithm, challenge.fetch("realm"), nonce, cnonce)
         ha2 = compute_ha2(algorithm, String(request.verb).upcase, uri)
 
-        compute_auth_header(algorithm, qop, nonce, cnonce, nonce_count, uri, ha1, ha2, challenge)
+        compute_auth_header(algorithm: algorithm, qop: qop, nonce: nonce, cnonce: cnonce,
+                            nonce_count: nonce_count, uri: uri, ha1: ha1, ha2: ha2,
+                            challenge: challenge)
       end
 
       # Compute digest and build the Authorization header string
       #
       # @return [String] formatted authorization header
       # @api private
-      def compute_auth_header(algorithm, qop, nonce, cnonce, nonce_count, uri, ha1, ha2, challenge) # rubocop:disable Metrics/ParameterLists
+      def compute_auth_header(algorithm:, qop:, nonce:, cnonce:, nonce_count:, uri:, ha1:, ha2:, challenge:)
         response = compute_response(algorithm, ha1, ha2, nonce: nonce,
                                     nonce_count: nonce_count, cnonce: cnonce, qop: qop)
 

lib/http/headers.rb

@@ -143,7 +143,7 @@ def add(name, value)
     # @api public
     def get(name)
       name = normalize_header name
-      @pile.select { |k, _| k.eql?(name) }.map { |_, _, v| v }
+      @pile.filter_map { |k, _, v| v if k.eql?(name) }
     end
 
     # Smart version of {#get}

sig/http.rbs

@@ -563,7 +563,7 @@ module HTTP
       def authorize: (Request request, Response response) -> Request
       def parse_challenge: (String header) -> Hash[String, String]
       def build_auth: (Request request, Hash[String, String] challenge) -> String
-      def compute_auth_header: (String algorithm, String? qop, String nonce, String cnonce, String nonce_count, String uri, String ha1, String ha2, Hash[String, String] challenge) -> String
+      def compute_auth_header: (algorithm: String, qop: String?, nonce: String, cnonce: String, nonce_count: String, uri: String, ha1: String, ha2: String, challenge: Hash[String, String]) -> String
       def select_qop: (String? qop_str) -> String?
       def compute_ha1: (String algorithm, String realm, String nonce, String cnonce) -> String
       def compute_ha2: (String algorithm, String method, String uri) -> String
@@ -1014,6 +1014,7 @@ module HTTP
       def redirect?: () -> bool
       def client_error?: () -> bool
       def server_error?: () -> bool
+      def not_modified?: () -> bool
       def to_sym: () -> Symbol?
       def inspect: () -> String
       def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, Integer | String?]

test/http/base64_test.rb

@@ -2,27 +2,27 @@
 
 require "test_helper"
 
-describe HTTP::Base64 do
+class HTTPBase64Test < Minitest::Test
   cover "HTTP::Base64*"
 
-  let(:encoder) do
-    klass = Class.new { include HTTP::Base64 }
-    klass.new
+  def encoder
+    @encoder ||= begin
+      klass = Class.new { include HTTP::Base64 }
+      klass.new
+    end
   end
 
-  describe "#encode64" do
-    it "encodes a string using strict Base64 (no newlines)" do
-      assert_equal "aGVsbG8=", encoder.send(:encode64, "hello")
-    end
+  def test_encode64_encodes_a_string_using_strict_base64
+    assert_equal "aGVsbG8=", encoder.send(:encode64, "hello")
+  end
 
-    it "produces output that round-trips back to the original input" do
-      input = "user:password"
+  def test_encode64_produces_output_that_round_trips_back_to_the_original_input
+    input = "user:password"
 
-      assert_equal input, encoder.send(:encode64, input).unpack1("m0")
-    end
+    assert_equal input, encoder.send(:encode64, input).unpack1("m0")
+  end
 
-    it "encodes empty string" do
-      assert_equal "", encoder.send(:encode64, "")
-    end
+  def test_encode64_encodes_empty_string
+    assert_equal "", encoder.send(:encode64, "")
   end
 end