Fix Server implementation and add more tests.

Author: ioquatix

lib/async/websocket/server.rb

@@ -13,37 +13,15 @@ module WebSocket
 		class Server < ::Protocol::HTTP::Middleware
 			include ::Protocol::WebSocket::Headers
 
-			def initialize(delegate, protocols: [], handler: Connection)
+			def initialize(delegate, **options, &block)
 				super(delegate)
 
-				@protocols = protocols
-				@handler = handler
-			end
-			
-			def select_protocol(request)
-				if requested_protocol = request.headers[SEC_WEBSOCKET_PROTOCOL]
-					return (requested_protocol & @protocols).first
-				end
-			end
-			
-			def response(request)
+				@options = options
+				@block = block
 			end
 
 			def call(request)
-				if request.protocol == PROTOCOL
-					# Select websocket sub-protocol:
-					protocol = select_protocol(request)
-					
-					# request.headers = nil
-					
-					Response.for(request, headers, protocol: protocol, **options) do |stream|
-						framer = Protocol::WebSocket::Framer.new(stream)
-						
-						yield handler.call(framer, protocol)
-					end
-				else
-					super
-				end
+				Async::WebSocket::Adapters::HTTP.open(request, **@options, &@block) or super
 			end
 		end
 	end

test/async/websocket/adapters/rack.rb

@@ -9,42 +9,49 @@
 require 'rack_application'
 
 describe Async::WebSocket::Adapters::Rack do
-	include RackApplication
-	
-	it "can make non-websocket connection to server" do
-		response = client.get("/")
-		
-		expect(response).to be(:success?)
-		expect(response.read).to be == "Hello World"
-		
-		client.close
-	end
-	
-	let(:message) do
-		Protocol::WebSocket::JSONMessage.generate({text: "Hello World"})
+	it "can determine whether a rack env is a websocket request" do
+		expect(Async::WebSocket::Adapters::Rack.websocket?(Rack::MockRequest.env_for("/"))).to be == false
+		expect(Async::WebSocket::Adapters::Rack.websocket?(Rack::MockRequest.env_for("/", 'HTTP_CONNECTION' => 'upgrade', 'HTTP_UPGRADE' => 'websocket'))).to be == true
 	end
 
-	it "can make websocket connection to server" do
-		Async::WebSocket::Client.connect(client_endpoint) do |connection|
-			connection.write(message)
+	with 'rack application' do
+		include RackApplication
+		
+		it "can make non-websocket connection to server" do
+			response = client.get("/")
 
-			expect(connection.read).to be == message
+			expect(response).to be(:success?)
+			expect(response.read).to be == "Hello World"
 
-			connection.close
+			client.close
 		end
-	end
-	
-	it "should use mask over insecure connection" do
-		expect(endpoint).not.to be(:secure?)
 
-		Async::WebSocket::Client.connect(client_endpoint) do |connection|
-			expect(connection.mask).not.to be_nil
+		let(:message) do
+			Protocol::WebSocket::JSONMessage.generate({text: "Hello World"})
 		end
-	end
-	
-	it "should negotiate protocol" do
-		Async::WebSocket::Client.connect(client_endpoint, protocols: ['ws']) do |connection|
-			expect(connection.protocol).to be == 'ws'
+		
+		it "can make websocket connection to server" do
+			Async::WebSocket::Client.connect(client_endpoint) do |connection|
+				connection.write(message)
+				
+				expect(connection.read).to be == message
+				
+				connection.close
+			end
+		end
+		
+		it "should use mask over insecure connection" do
+			expect(endpoint).not.to be(:secure?)
+			
+			Async::WebSocket::Client.connect(client_endpoint) do |connection|
+				expect(connection.mask).not.to be_nil
+			end
+		end
+		
+		it "should negotiate protocol" do
+			Async::WebSocket::Client.connect(client_endpoint, protocols: ['ws']) do |connection|
+				expect(connection.protocol).to be == 'ws'
+			end
 		end
 	end
 end

test/async/websocket/client.rb

@@ -1,8 +1,6 @@
 
 
 ClientExamples = Sus::Shared("a websocket client") do
-	include Sus::Fixtures::Async::HTTP::ServerContext
-	
 	let(:app) do
 		Protocol::HTTP::Middleware.for do |request|
 			Async::WebSocket::Adapters::HTTP.open(request) do |connection|
@@ -15,8 +13,6 @@
 		end
 	end
 
-	let(:timeout) {nil}
-	
 	it "can connect to a websocket server and close underlying client" do
 		Async do |task|
 			connection = Async::WebSocket::Client.connect(client_endpoint)
@@ -31,11 +27,15 @@
 end
 
 describe Async::WebSocket::Client do
-	with "http/1", protocol: Async::HTTP::Protocol::HTTP1 do
+	include Sus::Fixtures::Async::HTTP::ServerContext
+
+	with 'http/1' do
+		let(:protocol) {Async::HTTP::Protocol::HTTP1}
 		it_behaves_like ClientExamples
 	end
-
-	with "http/2", protocol: Async::HTTP::Protocol::HTTP2 do
+	
+	with 'http/2' do
+		let(:protocol) {Async::HTTP::Protocol::HTTP2}
 		it_behaves_like ClientExamples
 	end
 end

test/async/websocket/server.rb

@@ -4,6 +4,7 @@
 # Copyright, 2022, by Samuel Williams.
 
 require 'protocol/websocket/json_message'
+require 'protocol/http/middleware/builder'
 
 require 'async/websocket/client'
 require 'async/websocket/server'
@@ -12,54 +13,77 @@
 require 'sus/fixtures/async/http/server_context'
 
 ServerExamples = Sus::Shared('a websocket server') do
-	include Sus::Fixtures::Async::HTTP::ServerContext
-	
-	let(:message) {"Hello World"}
-	
-	let(:app) do
-		Protocol::HTTP::Middleware.for do |request|
-			Async::WebSocket::Adapters::HTTP.open(request) do |connection|
-				connection.send_text(message)
-				connection.close
-			end or Protocol::HTTP::Response[404, {}, []]
-		end
-	end
-	
 	let(:websocket_client) {Async::WebSocket::Client.open(client_endpoint)}
 
-	it "can establish connection" do
-		connection = websocket_client.connect(endpoint.authority, "/server")
-		
-		begin
-			expect(connection.read).to be == message
-			expect(connection.read).to be_nil
-			expect(connection).to be(:closed?)
-		ensure
-			connection.close
-		end
-	end
-	
-	with "headers" do
-		let(:headers) {{"foo" => "bar"}}
+	with 'generic application' do
+		let(:message) {"Hello World"}
 
 		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.send_text(message)
 					connection.close
 				end or Protocol::HTTP::Response[404, {}, []]
 			end
 		end
 
-		it "can send headers" do
-			connection = websocket_client.connect(endpoint.authority, "/headers", headers: headers)
+		it "can establish connection" do
+			connection = websocket_client.connect(endpoint.authority, "/server")
 
 			begin
-				json_message = Protocol::WebSocket::JSONMessage.wrap(connection.read)
+				expect(connection.read).to be == message
+				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)
 
-				expect(json_message.to_h).to have_keys(*headers.keys)
+				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")
+					connection.close
+				end
+			end
+		end
+		
+		it "can establish connection" do
+			connection = websocket_client.connect(endpoint.authority, "/server")
+			
+			begin
+				expect(connection.read).to be == "Hello World"
 				expect(connection.read).to be_nil
 				expect(connection).to be(:closed?)
 			ensure
@@ -69,14 +93,16 @@
 	end
 end
 
-describe Async::HTTP::Protocol::HTTP1 do
-	let(:protocol) {subject}
+describe Async::WebSocket::Server do
+	include Sus::Fixtures::Async::HTTP::ServerContext
 
-	it_behaves_like ServerExamples
-end
-
-describe Async::HTTP::Protocol::HTTP2 do
-	let(:protocol) {subject}
+	with 'http/1' do
+		let(:protocol) {Async::HTTP::Protocol::HTTP1}
+		it_behaves_like ServerExamples
+	end
 
-	it_behaves_like ServerExamples
+	with 'http/2' do
+		let(:protocol) {Async::HTTP::Protocol::HTTP2}
+		it_behaves_like ServerExamples
+	end
 end