100% coverage for Connection.

Author: ioquatix

lib/async/websocket/adapters/http.rb

@@ -35,7 +35,6 @@ def self.open(request, headers: [], protocols: [], handler: Connection, extensio
 						end
 
 						response = Response.for(request, headers, protocol: protocol, **options) do |stream|
-							
 							framer = Protocol::WebSocket::Framer.new(stream)
 							connection = handler.call(framer, protocol, extensions)
 

lib/async/websocket/connect_response.rb

@@ -18,8 +18,9 @@ def initialize(request, headers = nil, protocol: nil, &block)
 				if protocol
 					headers.add(SEC_WEBSOCKET_PROTOCOL, protocol)
 				end
-
+				
 				body = Async::HTTP::Body::Hijack.wrap(request, &block)
+				
 				super(request.version, 200, headers, body)
 			end
 		end

lib/async/websocket/connection.rb

@@ -41,10 +41,6 @@ def reusable?
 			end
 
 			attr :protocol
-			
-			def call
-				self.close
-			end
 		end
 	end
 end

lib/async/websocket/upgrade_response.rb

@@ -19,16 +19,17 @@ def initialize(request, headers = nil, protocol: nil, &block)
 				if accept_nounce = request.headers[SEC_WEBSOCKET_KEY]&.first
 					headers.add(SEC_WEBSOCKET_ACCEPT, Nounce.accept_digest(accept_nounce))
 					status = 101
+					
+					if protocol
+						headers.add(SEC_WEBSOCKET_PROTOCOL, protocol)
+					end
+					
+					body = Async::HTTP::Body::Hijack.wrap(request, &block)
+					
+					super(request.version, 101, headers, body, PROTOCOL)
 				else
-					status = 400
+					super(request.version, 400, headers)
 				end
-				
-				if protocol
-					headers.add(SEC_WEBSOCKET_PROTOCOL, protocol)
-				end
-				
-				body = Async::HTTP::Body::Hijack.wrap(request, &block)
-				super(request.version, status, headers, body, PROTOCOL)
 			end
 		end
 	end

test/async/websocket/server.rb

@@ -15,75 +15,71 @@
 ServerExamples = Sus::Shared('a websocket server') do
 	let(:websocket_client) {Async::WebSocket::Client.open(client_endpoint)}
 
-	with 'generic application' do
-		let(:message) {"Hello World"}
+	it "can establish connection" do
+		connection = websocket_client.connect(endpoint.authority, "/server")
+		
+		connection.send_text("Hello World!")
+		message = connection.read
+		expect(message.to_str).to be == "Hello World!"
+		
+		connection.close
+	end
+	
+	it "can establish connection with block" do
+		websocket_client.connect(endpoint.authority, "/server") do |connection|
+			connection.send_text("Hello World!")
+			message = connection.read
+			expect(message.to_str).to be == "Hello World!"
+		end
+	end
+	
+	with "headers" do
+		let(:headers) {{"foo" => "bar"}}
 
 		let(:app) do
 			Protocol::HTTP::Middleware.for do |request|
 				Async::WebSocket::Adapters::HTTP.open(request) do |connection|
-					connection.send_text(message)
+					message = Protocol::WebSocket::JSONMessage.generate(request.headers.fields)
+					message.send(connection)
+					
 					connection.close
 				end or Protocol::HTTP::Response[404, {}, []]
 			end
 		end
 
-		it "can establish connection" do
-			connection = websocket_client.connect(endpoint.authority, "/server")
+		it "can send headers" do
+			connection = websocket_client.connect(endpoint.authority, "/headers", headers: headers)
 
 			begin
-				expect(connection.read).to be == message
+				json_message = Protocol::WebSocket::JSONMessage.wrap(connection.read)
+				
+				expect(json_message.to_h).to have_keys(*headers.keys)
 				expect(connection.read).to be_nil
 				expect(connection).to be(:closed?)
 			ensure
 				connection.close
 			end
 		end
-		
-		with "headers" do
-			let(:headers) {{"foo" => "bar"}}
-			
-			let(:app) do
-				Protocol::HTTP::Middleware.for do |request|
-					Async::WebSocket::Adapters::HTTP.open(request) do |connection|
-						message = Protocol::WebSocket::JSONMessage.generate(request.headers.fields)
-						message.send(connection)
-						
-						connection.close
-					end or Protocol::HTTP::Response[404, {}, []]
-				end
-			end
-			
-			it "can send headers" do
-				connection = websocket_client.connect(endpoint.authority, "/headers", headers: headers)
-				
-				begin
-					json_message = Protocol::WebSocket::JSONMessage.wrap(connection.read)
-					
-					expect(json_message.to_h).to have_keys(*headers.keys)
-					expect(connection.read).to be_nil
-					expect(connection).to be(:closed?)
-				ensure
-					connection.close
-				end
-			end
-		end
 	end
 
 	with 'server middleware' do
 		let(:app) do
 			Protocol::HTTP::Middleware.build do
-				use Async::WebSocket::Server do |connection|
-					connection.send_text("Hello World")
+				use Async::WebSocket::Server, protocols: ['echo', 'baz'] do |connection|
+					connection.send_text("protocol: #{connection.protocol}")
 					connection.close
 				end
 			end
 		end
 
-		it "can establish connection" do
-			connection = websocket_client.connect(endpoint.authority, "/server")
+		it "can establish connection with explicit protocol" do
+			connection = websocket_client.connect(endpoint.authority, "/server", protocols: ['echo', 'foo', 'bar'])
+			
+			# The negotiated protocol:
+			expect(connection.protocol).to be == 'echo'
 
 			begin
-				expect(connection.read).to be == "Hello World"
+				expect(connection.read).to be == "protocol: echo"
 				expect(connection.read).to be_nil
 				expect(connection).to be(:closed?)
 			ensure
@@ -96,9 +92,30 @@
 describe Async::WebSocket::Server do
 	include Sus::Fixtures::Async::HTTP::ServerContext
 
+	let(:app) do
+		Protocol::HTTP::Middleware.for do |request|
+			Async::WebSocket::Adapters::HTTP.open(request) do |connection|
+				while message = connection.read
+					connection.write(message)
+				end
+			end or Protocol::HTTP::Response[404, {}, []]
+		end
+	end
+	
 	with 'http/1' do
 		let(:protocol) {Async::HTTP::Protocol::HTTP1}
 		it_behaves_like ServerExamples
+		
+		it "fails with bad request if missing nounce" do
+			request = Protocol::HTTP::Request["GET", "/", {
+				"upgrade" => "websocket",
+				"connection" => "upgrade",
+			}]
+			
+			response = client.call(request)
+			
+			expect(response).to be(:bad_request?)
+		end
 	end
 
 	with 'http/2' do