100% coverage.

Author: ioquatix

lib/async/websocket/client.rb

@@ -103,6 +103,8 @@ def connect(authority, path, headers: nil, handler: Connection, extensions: ::Pr
 				response = request.call(connection)
 
 				unless response.stream?
+					response.close
+					
 					raise ProtocolError, "Failed to negotiate connection: #{response.status}"
 				end
 

lib/async/websocket/connect_request.rb

@@ -20,13 +20,14 @@ class ConnectRequest < ::Protocol::HTTP::Request
 			class Wrapper
 				def initialize(stream, response)
 					@response = response
-					@body = @response.body
 					@stream = stream
 				end
 
-				attr_accessor :response
+				def close
+					@response.close
+				end
 
-				attr_accessor :body
+				attr_accessor :response
 				attr_accessor :stream
 
 				def stream?
@@ -40,14 +41,6 @@ def status
 				def headers
 					@response.headers
 				end
-				
-				def body?
-					true
-				end
-				
-				def protocol
-					@response.protocol
-				end
 			end
 
 			class Hijack < Protocol::HTTP::Body::Readable

lib/async/websocket/error.rb

@@ -9,5 +9,11 @@ module Async
 	module WebSocket
 		class ProtocolError < ::Protocol::WebSocket::ProtocolError
 		end
+		
+		class Error < ::Protocol::WebSocket::Error
+		end
+		
+		class UnsupportedVersionError < Error
+		end
 	end
 end

lib/async/websocket/request.rb

@@ -5,6 +5,7 @@
 
 require_relative 'connect_request'
 require_relative 'upgrade_request'
+require_relative 'error'
 
 module Async
 	module WebSocket
@@ -26,6 +27,10 @@ def initialize(scheme = nil, authority = nil, path = nil, headers = nil, **optio
 				@body = nil
 			end
 
+			def protocol
+				PROTOCOL
+			end
+			
 			attr_accessor :scheme
 			attr_accessor :authority
 			attr_accessor :path
@@ -41,15 +46,16 @@ def call(connection)
 					return ConnectRequest.new(self, **@options).call(connection)
 				end
 
-				raise HTTP::Error, "Unsupported HTTP version: #{connection.version}!"
+				raise UnsupportedVersionError, "Unsupported HTTP version: #{connection.version}!"
 			end
 
 			def idempotent?
 				true
 			end
 
 			def to_s
-				"\#<#{self.class} #{@scheme}://#{@authority}: #{@path}>"
+				uri = "#{@scheme}://#{@authority}#{@path}"
+				"\#<#{self.class} uri=#{uri.inspect}>"
 			end
 		end
 	end

lib/async/websocket/response.rb

@@ -19,7 +19,7 @@ def self.for(request, headers = nil, **options, &body)
 					return ConnectResponse.new(request, headers, **options, &body)
 				end
 
-				raise ProtocolError, "Unsupported HTTP version: #{request.version}!"
+				raise UnsupportedVersionError, "Unsupported HTTP version: #{request.version}!"
 			end
 		end
 	end

lib/async/websocket/upgrade_request.rb

@@ -25,6 +25,10 @@ def initialize(response)
 					@stream = nil
 				end
 
+				def close
+					@response.close
+				end
+				
 				attr_accessor :response
 
 				def stream?
@@ -39,18 +43,6 @@ def headers
 					@response.headers
 				end
 
-				def body?
-					false
-				end
-				
-				def body
-					nil
-				end
-				
-				def protocol
-					@response.protocol
-				end
-				
 				def stream
 					@stream ||= @response.hijack!
 				end

test/async/websocket/client.rb

@@ -1,4 +1,11 @@
+# frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require 'async/websocket/client'
+
+require 'sus/fixtures/async/http/server_context'
 
 ClientExamples = Sus::Shared("a websocket client") do
 	let(:app) do
@@ -24,6 +31,20 @@
 			expect(task.children).to be(:empty?)
 		end.wait
 	end
+	
+	with 'missing support for websockets' do
+		let(:app) do
+			Protocol::HTTP::Middleware.for do |request|
+				Protocol::HTTP::Response[404, {}, []]
+			end
+		end
+		
+		it "raises an error when the server doesn't support websockets" do
+			expect do
+				Async::WebSocket::Client.connect(client_endpoint) {}
+			end.to raise_exception(Async::WebSocket::ProtocolError, message: be =~ /Failed to negotiate connection/)
+		end
+	end
 end
 
 describe Async::WebSocket::Client do

test/async/websocket/request.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022, by Samuel Williams.
+
+require 'async/websocket/request'
+
+describe Async::WebSocket::Request do
+	let(:request) {subject.new("https", "localhost", "/")}
+	let(:connection) {Async::WebSocket::Connection.new(nil)}
+	
+	it "can detect websocket requests" do
+		expect(subject).to be(:websocket?, request)
+	end
+	
+	it "should be idempotent" do
+		expect(request).to be(:idempotent?)
+	end
+	
+	it "fails if the version is not supported" do
+		expect(connection).to receive(:http1?).and_return(false)
+		expect(connection).to receive(:http2?).and_return(false)
+		expect(connection).to receive(:version).and_return("frob/2.0")
+		
+		expect do
+			request.call(connection)
+		end.to raise_exception(Async::WebSocket::UnsupportedVersionError, message: be =~ /Unsupported HTTP version/)
+	end
+	
+	with '#to_s' do
+		it "should generate string representation" do
+			expect(request.to_s).to be =~ %r{https://localhost/}
+		end
+	end
+end

test/async/websocket/response.rb

@@ -11,6 +11,6 @@
 
 		expect do
 			subject.for(request)
-		end.to raise_exception(Async::WebSocket::ProtocolError, message: be =~ /Unsupported HTTP version/)
+		end.to raise_exception(Async::WebSocket::UnsupportedVersionError, message: be =~ /Unsupported HTTP version/)
 	end
 end

test/async/websocket/server.rb

@@ -13,8 +13,6 @@
 require 'sus/fixtures/async/http/server_context'
 
 ServerExamples = Sus::Shared('a websocket server') do
-	let(:websocket_client) {Async::WebSocket::Client.open(client_endpoint)}
-	
 	it "can establish connection" do
 		connection = websocket_client.connect(endpoint.authority, "/server")
 
@@ -102,6 +100,8 @@
 describe Async::WebSocket::Server do
 	include Sus::Fixtures::Async::HTTP::ServerContext
 
+	let(:websocket_client) {Async::WebSocket::Client.open(client_endpoint)}
+	
 	let(:app) do
 		Protocol::HTTP::Middleware.for do |request|
 			Async::WebSocket::Adapters::HTTP.open(request) do |connection|
@@ -114,7 +114,7 @@
 
 	with 'http/1' do
 		let(:protocol) {Async::HTTP::Protocol::HTTP1}
-		it_behaves_like ServerExamples
+		it_behaves_like ServerExamples 
 
 		it "fails with bad request if missing nounce" do
 			request = Protocol::HTTP::Request["GET", "/", {
@@ -126,6 +126,34 @@
 
 			expect(response).to be(:bad_request?)
 		end
+		
+		let(:timeout) {nil}
+		
+		with 'broken server' do
+			let(:app) do
+				Protocol::HTTP::Middleware.for do |request|
+					response = Async::WebSocket::Adapters::HTTP.open(request) do |connection|
+						while message = connection.read
+							connection.write(message)
+						end
+					end
+					
+					if response
+						response.tap do
+							response.headers.set('sec-websocket-accept', '2badsheep')
+						end
+					else
+						Protocol::HTTP::Response[404, {}, []]
+					end
+				end
+			end
+			
+			it "fails with protocol error if nounce doesn't match" do
+				expect do
+					websocket_client.connect(endpoint.authority, "/server") {}
+				end.to raise_exception(Protocol::WebSocket::ProtocolError)
+			end
+		end
 	end
 
 	with 'http/2' do