Improve test coverage. (#28)

Author: samuel-williams-shopify

lib/protocol/rack/adapter/rack2.rb

@@ -165,7 +165,11 @@ def self.make_response(env, response)
 					end
 
 					headers.transform_values! do |value|
-						value.is_a?(Array) ? value.join("\n") : value
+						if value.is_a?(Array)
+							value.join("\n")
+						else
+							value
+						end
 					end
 
 					[response.status, headers, body]

lib/protocol/rack/adapter/rack3.rb

@@ -33,14 +33,6 @@ def self.parse_file(...)
 					::Rack::Builder.parse_file(...)
 				end
 
-				# Whether this adapter supports streaming responses.
-				# Rack 3 supports streaming responses by default.
-				# 
-				# @returns [Boolean] Always true for the Rack 3 adapter.
-				def self.streaming?
-					true
-				end
-				
 				# Create a Rack 3 environment hash for the request.
 				# Sets up all required Rack 3 environment variables and processes the request.
 				# Unlike Rack 2, this adapter doesn't set Rack version or threading flags.

lib/protocol/rack/body/enumerable.rb

@@ -87,8 +87,10 @@ def close(error = nil)
 				# 	@parameter chunk [String] A chunk of the response body.
 				def each(&block)
 					@body.each(&block)
+				rescue => error
+					raise
 				ensure
-					self.close($!)
+					self.close(error)
 				end
 
 				# Check if the body is a streaming response.
@@ -105,8 +107,10 @@ def stream?
 				# @parameter stream [Object] The stream to write the body to.
 				def call(stream)
 					@body.call(stream)
+				rescue => error
+					raise
 				ensure
-					self.close($!)
+					self.close(error)
 				end
 
 				# Read the next chunk from the response body.

lib/protocol/rack/response.rb

@@ -5,10 +5,10 @@
 
 require_relative "body"
 require_relative "constants"
-# require 'time'
 
 require "protocol/http/response"
 require "protocol/http/headers"
+require "protocol/http/body/head"
 
 module Protocol
 	module Rack

test/protocol/rack/adapter.rb

@@ -19,6 +19,62 @@
 		expect(subject.parse_file(rackup_path)).to be_a(Proc)
 	end
 
+	with ".make_response" do
+		let(:env) {Rack::MockRequest.env_for("/")}
+		
+		it "can make a response" do
+			response = Protocol::HTTP::Response[200, headers: {}, body: ["Hello World!"]]
+			status, headers, body = subject.make_response(env, response)
+
+			expect(status).to be == 200
+			expect(headers).to be == {}
+			expect(body.join).to be == "Hello World!"
+		end
+
+		it "can make a streaming response" do
+			stream_proc = lambda do |stream|
+				stream.write("Hello Streaming World")
+				stream.close
+			end
+
+			body = Protocol::Rack::Body::Streaming.new(stream_proc)
+			
+			response = Protocol::HTTP::Response[200, headers: {}, body: body]
+			status, headers, body = subject.make_response(env, response)
+
+			expect(status).to be == 200
+			if headers.include?(Protocol::Rack::RACK_HIJACK)
+				hijack_proc = headers[Protocol::Rack::RACK_HIJACK]
+				expect(hijack_proc).to be(:respond_to?, :call)
+			else
+				expect(body).to be(:respond_to?, :call)
+			end
+		end
+
+		it "can wrap headers" do
+			response = Protocol::HTTP::Response[200, headers: {"x-custom" => "123"}, body: ["Hello World!"]]
+			status, headers, body = subject.make_response(env, response)
+
+			x_custom = headers["x-custom"]
+
+			expect(x_custom).to (be == "123").or(be == ["123"])
+		end
+
+		it "can wrap multi-value headers" do
+			response = Protocol::HTTP::Response[200, headers: [["x-custom", "a=b"], ["x-custom", "x=y"]], body: ["Hello World!"]]
+			
+			status, headers, body = subject.make_response(env, response)
+			
+			x_custom = headers["x-custom"]
+
+			if subject::VERSION < "3"
+				expect(x_custom).to be == "a=b\nx=y"
+			else
+				expect(x_custom).to be == ["a=b", "x=y"]
+			end
+		end
+	end
+
 	AnApplication = Sus::Shared("an application") do
 		include Protocol::Rack::ServerContext
 

test/protocol/rack/adapter/rack2.rb

@@ -3,121 +3,146 @@
 # Released under the MIT License.
 # Copyright, 2022-2025, by Samuel Williams.
 
-require "sus/fixtures/console"
 require "protocol/rack/adapter/rack2"
 
+require "sus/fixtures/console"
+
+require "rack"
+require "protocol/rack/body/streaming"
+
 describe Protocol::Rack::Adapter::Rack2 do
 	include Sus::Fixtures::Console::CapturedLogger
 
-	let(:app) {->(env) {[200, {}, []]}}
-	let(:adapter) {subject.new(app)}
-	
-	let(:body) {Protocol::HTTP::Body::Buffered.new}
-	let(:request) {Protocol::HTTP::Request.new("https", "example.com", "GET", "/", "http/1.1", Protocol::HTTP::Headers[{"accept" => "text/html"}], body)}
-	let(:response) {adapter.call(request)}
-	
-	with "set-cookie headers that has multiple values" do
-		let(:app) {->(env) {[200, {"set-cookie" => "a=b\nx=y"}, []]}}
+	with "#call" do
+		let(:app) {->(env) {[200, {}, []]}}
+		let(:adapter) {subject.new(app)}
 
-		it "can make a response newline separated headers" do
-			expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
-		end
-	end
-	
-	with "content-length header" do
-		let(:app) {->(env) {[200, {"content-length" => "10"}, ["1234567890"]]}}
+		let(:body) {Protocol::HTTP::Body::Buffered.new}
+		let(:request) {Protocol::HTTP::Request.new("https", "example.com", "GET", "/", "http/1.1", Protocol::HTTP::Headers[{"accept" => "text/html"}], body)}
+		let(:response) {adapter.call(request)}
 
-		it "removes content-length header" do
-			expect(response.headers).not.to be(:include?, "content-length")
+		with "set-cookie headers that has multiple values" do
+			let(:app) {->(env) {[200, {"set-cookie" => "a=b\nx=y"}, []]}}
+			
+			it "can make a response newline separated headers" do
+				expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
+			end
 		end
-	end
-	
-	with "connection: close header" do
-		let(:app) {->(env) {[200, {"connection" => "close"}, []]}}
 
-		it "removes content-length header" do
-			expect(response.headers).not.to be(:include?, "connection")
-		end
-	end
-	
-	with "body that responds to #to_path" do
-		let(:body) {Array.new}
-		let(:app) {->(env) {[200, {}, body]}}
-	
-		it "should generate file body" do
-			expect(body).to receive(:to_path).and_return("/dev/null")
-						
-			expect(response.body).to be_a(Protocol::HTTP::Body::File)
-		end
-	
-		with "206 partial response status" do
-			let(:app) {->(env) {[200, {}, body]}}
+		with "content-length header" do
+			let(:app) {->(env) {[200, {"content-length" => "10"}, ["1234567890"]]}}
 
-			it "should not modify partial responses" do
-				expect(response.body).to be_a(Protocol::Rack::Body::Enumerable)
+			it "removes content-length header" do
+				expect(response.headers).not.to be(:include?, "content-length")
 			end
 		end
-	end
-	
-	with "a hijacked response" do
-		let(:callback) {->(stream){}}
-		let(:app) {->(env){[200, {"rack.hijack" => callback}, []]}}
 
-		it "should support hijacking" do
-			expect(response.body).to be_a(Protocol::Rack::Body::Streaming)
-		end
-	end
-	
-	with "response handling" do
-		with "array response" do
-			let(:app) {->(env) {[200, {}, ["Hello"]]}}
+		with "connection: close header" do
+			let(:app) {->(env) {[200, {"connection" => "close"}, []]}}
 
-			it "handles array response correctly" do
-				expect(response.body).to be_a(Protocol::Rack::Body::Enumerable)
+			it "removes content-length header" do
+				expect(response.headers).not.to be(:include?, "connection")
 			end
 		end
 
-		# with "string response" do
-		# 	let(:app) {->(env) {[200, {}, "Hello"]}}
-			
-		# 	it "handles string response correctly" do
-		# 		expect(response.status).to be == 500
-		# 		expect(response.read).to be == "ArgumentError: Body must respond to #each!"
-		# 	end
-		# end
-	end
-	
-	with "header transformation" do
-		with "array values" do
-			let(:app) {->(env) {[200, {"x-custom" => "a\nb"}, []]}}
-			
-			it "joins array values with newlines in response" do
-				expect(response.headers["x-custom"]).to be == ["a", "b"]
+		with "body that responds to #to_path" do
+			let(:body) {Array.new}
+			let(:app) {->(env) {[200, {}, body]}}
+		
+			it "should generate file body" do
+				expect(body).to receive(:to_path).and_return("/dev/null")
+							
+				expect(response.body).to be_a(Protocol::HTTP::Body::File)
+			end
+		
+			with "206 partial response status" do
+				let(:app) {->(env) {[200, {}, body]}}
+				
+				it "should not modify partial responses" do
+					expect(response.body).to be_a(Protocol::Rack::Body::Enumerable)
+				end
 			end
 		end
 
-		with "non-array values" do
-			let(:app) {->(env) {[200, {"x-custom" => "value"}, []]}}
+		with "a hijacked response" do
+			let(:callback) {->(stream){}}
+			let(:app) {->(env){[200, {"rack.hijack" => callback}, []]}}
 
-			it "preserves non-array values" do
-				expect(response.headers["x-custom"]).to be == ["value"]
+			it "should support hijacking" do
+				expect(response.body).to be_a(Protocol::Rack::Body::Streaming)
 			end
 		end
 
-		with "multiple set-cookie headers" do
-			let(:app) {->(env) {[200, {"set-cookie" => "a=b\nx=y"}, []]}}
-			
-			it "joins set-cookie headers with newlines" do
-				expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
+		with "response handling" do
+			with "array response" do
+				let(:app) {->(env) {[200, {}, ["Hello"]]}}
+				
+				it "handles array response correctly" do
+					expect(response.body).to be_a(Protocol::Rack::Body::Enumerable)
+				end
 			end
 		end
 
-		with "rack specific headers" do
-			let(:app) {->(env) {[200, {"rack.hijack" => ->(stream){}}, []]}}
+		with "header transformation" do
+			with "array values" do
+				let(:app) {->(env) {[200, {"x-custom" => "a\nb"}, []]}}
+				
+				it "joins array values with newlines in response" do
+					expect(response.headers["x-custom"]).to be == ["a", "b"]
+				end
+			end
+			
+			with "non-array values" do
+				let(:app) {->(env) {[200, {"x-custom" => "value"}, []]}}
+				
+				it "preserves non-array values" do
+					expect(response.headers["x-custom"]).to be == ["value"]
+				end
+			end
 
-			it "preserves rack specific headers in meta" do
-				expect(response.headers).not.to be(:include?, "rack.hijack")
+			with "multiple set-cookie headers" do
+				let(:app) {->(env) {[200, {"set-cookie" => "a=b\nx=y"}, []]}}
+				
+				it "joins set-cookie headers with newlines" do
+					expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
+				end
 			end
+			
+			with "rack specific headers" do
+				let(:app) {->(env) {[200, {"rack.hijack" => ->(stream){}}, []]}}
+				
+				it "preserves rack specific headers in meta" do
+					expect(response.headers).not.to be(:include?, "rack.hijack")
+				end
+			end
+		end
+	end
+
+	with "#make_response" do
+		let(:env) {::Rack::MockRequest.env_for("/")}
+
+		it "can wrap response" do
+			response = Protocol::HTTP::Response[200, headers: {}, body: []]
+			status, headers, body = subject.make_response(env, response)
+
+			expect(status).to be == 200
+			expect(headers).to be == {}
+			expect(body).to be_a(Protocol::HTTP::Body::Buffered)
+			expect(body).to be(:empty?)
+		end
+
+
+		it "can wrap streaming response" do
+			streaming_body = Protocol::Rack::Body::Streaming.new(->(stream){})
+			response = Protocol::HTTP::Response[200, headers: {}, body: streaming_body]
+
+			env[Protocol::Rack::RACK_IS_HIJACK] = true
+
+			status, headers, body = subject.make_response(env, response)
+
+			expect(status).to be == 200
+			expect(headers).to have_keys(Protocol::Rack::RACK_HIJACK)
+			expect(body).to be == []
 		end
 	end
-end
+end