strelka 0.15.0 → 0.16.0

data/spec/strelka/websocketserver/heartbeat_spec.rb

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# frozen-string-literal: true
+
+require_relative '../../helpers'
+
+require 'strelka'
+require 'strelka/plugins'
+require 'strelka/websocketserver/heartbeat'
+
+require 'strelka/behavior/plugin'
+
+
+RSpec.describe Strelka::WebSocketServer::Heartbeat do
+
+	it_should_behave_like( "A Strelka Plugin" )
+
+end
+

data/spec/strelka/websocketserver/routing_spec.rb

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 # vim: set nosta noet ts=4 sw=4:
-# encoding: utf-8
+# frozen-string-literal: true
 
 require_relative '../../helpers'
 
@@ -17,10 +17,10 @@ require 'strelka/behavior/plugin'
 ###	C O N T E X T S
 #####################################################################
 
-describe Strelka::WebSocketServer::Routing do
+RSpec.describe Strelka::WebSocketServer::Routing do
 
 	before( :all ) do
-		@frame_factory = Mongrel2::WebSocketFrameFactory.new( route: '/chat' )
+		@request_factory = Mongrel2::WebSocketRequestFactory.new( route: '/chat' )
 	end
 
 
@@ -29,8 +29,8 @@ describe Strelka::WebSocketServer::Routing do
 
 	describe "an including App" do
 
-		before( :each ) do
-			@app = Class.new( Strelka::WebSocketServer ) do
+		let( :app_class ) do
+			Class.new( Strelka::WebSocketServer ) do
 				plugin :routing
 				def initialize( appid='chat-test', sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
 					super
@@ -40,32 +40,34 @@ describe Strelka::WebSocketServer::Routing do
 
 
 		it "has an Hash of raw routes" do
-			expect( @app.op_callbacks ).to be_a( Hash )
+			expect( app_class.op_callbacks ).to be_a( Hash )
 		end
 
+
 		it "knows what its route methods are" do
-			expect( @app.op_callbacks ).to eq( {} )
-			@app.class_eval do
+			expect( app_class.op_callbacks ).to eq( {} )
+			app_class.class_eval do
 				on_text() {}
 				on_binary() {}
 				on_ping() {}
 			end
 
-			expect( @app.op_callbacks.keys ).to eq([ :text, :binary, :ping ])
+			expect( app_class.op_callbacks.keys ).to eq([ :text, :binary, :ping ])
 		end
 
+
 		it "allows the declaration of custom opcodes" do
-			@app.opcodes( 0x3 => :nick )
-			@app.class_eval do
+			app_class.opcodes( nick: 0x3 )
+			app_class.class_eval do
 				on_nick() {}
 			end
-			expect( @app.op_callbacks.size ).to eq(  1  )
-			expect( @app.op_callbacks[ :nick ] ).to be_a( UnboundMethod )
+			expect( app_class.op_callbacks.size ).to eq(  1  )
+			expect( app_class.op_callbacks[ :nick ] ).to be_a( UnboundMethod )
 		end
 
 
 		it "dispatches TEXT frames to a text handler if one is declared" do
-			@app.class_eval do
+			app_class.class_eval do
 				on_text do |frame|
 					res = frame.response
 					res.puts( "#{frame.body.read} Yep!" )
@@ -73,38 +75,38 @@ describe Strelka::WebSocketServer::Routing do
 				end
 			end
 
-			frame = @frame_factory.text( "/chat", "Clowns?" )
-			response = @app.new.handle_websocket( frame )
+			frame = @request_factory.text( "/chat", "Clowns?" )
+			response = app_class.new.handle_websocket( frame )
 
-			expect( response ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( response ).to be_a( Mongrel2::WebSocket::Response )
 			expect( response.opcode ).to eq( :text )
-			response.body.rewind
-			expect( response.body.read ).to eq( "Clowns? Yep!\n" )
+			response.payload.rewind
+			expect( response.payload.read ).to eq( "Clowns? Yep!\n" )
 		end
 
+
 		it "dispatches custom frame type to its handler if one is declared" do
-			@app.class_eval do
-				opcodes 0xB => :refresh
+			app_class.class_eval do
+				opcodes refresh: 0xb
 
 				on_refresh do |frame|
 					return frame.response
 				end
 			end
 
-			frame = @frame_factory.create( '/chat', '', 0xB )
-			response = @app.new.handle_websocket( frame )
+			frame = @request_factory.create( '/chat', '', 0xb )
+			response = app_class.new.handle_websocket( frame )
 
-			expect( response ).to be_a( Mongrel2::WebSocket::Frame )
-			expect( response.opcode ).to eq( :reserved )
-			expect( response.numeric_opcode ).to eq( 0xB )
+			expect( response ).to be_a( Mongrel2::WebSocket::Response )
+			expect( response.numeric_opcode ).to eq( 0xb )
 		end
 
 
 		it "falls back to the defaults if a handler isn't declared for a frame" do
-			frame = @frame_factory.text( '/chat', '' )
-			response = @app.new.handle_websocket( frame )
+			frame = @request_factory.text( '/chat', '' )
+			response = app_class.new.handle_websocket( frame )
 
-			expect( response ).to be_a( Mongrel2::WebSocket::Frame )
+			expect( response ).to be_a( Mongrel2::WebSocket::Response )
 			expect( response.opcode ).to eq( :close )
 		end
 

data/spec/strelka/websocketserver_spec.rb

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 # vim: set nosta noet ts=4 sw=4:
-# encoding: utf-8
+# frozen-string-literal: true
 
 require_relative '../helpers'
 
@@ -15,11 +15,12 @@ require 'strelka/websocketserver'
 ###	C O N T E X T S
 #####################################################################
 
-describe Strelka::WebSocketServer do
+RSpec.describe Strelka::WebSocketServer do
 
 	before( :all ) do
 		@initial_registry = described_class.loaded_plugins.dup
-		@frame_factory = Mongrel2::WebSocketFrameFactory.new( route: '/chat' )
+		@request_factory = Mongrel2::WebSocketRequestFactory.new( route: '/chat' )
+
 		Mongrel2::Config.db = Mongrel2::Config.in_memory_db
 		Mongrel2::Config.init_database
 
@@ -28,12 +29,19 @@ describe Strelka::WebSocketServer do
 		strelkaspec = make_gemspec( 'strelka', Strelka::VERSION, false )
 		loaded_specs = Gem.instance_variable_get( :@loaded_specs )
 		loaded_specs['strelka'] = strelkaspec
-
 	end
 
 	before( :each ) do
 		described_class.loaded_plugins.clear
-		@app = Class.new( described_class ) do
+	end
+
+	after( :all ) do
+		described_class.loaded_plugins = @initial_registry
+	end
+
+
+	let( :app_class ) do
+		return Class.new( described_class ) do
 			def initialize( appid=TEST_APPID, sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
 				super
 			end
@@ -43,104 +51,231 @@ describe Strelka::WebSocketServer do
 		end
 	end
 
-	after( :each ) do
-		@app = nil
+
+	it "uses the app's ID constant for the appid if .run is called without one" do
+		app_class.const_set( :ID, 'chat-server' )
+		expect( app_class.default_appid ).to eq( 'chat-server' )
 	end
 
-	after( :all ) do
-		described_class.loaded_plugins = @initial_registry
+
+	it "uses the app's name for the appid it has no ID constant" do
+		app_class.class_eval do
+			def self::name; "Acme::Valhalla::EventServer" ; end
+		end
+
+		expect( app_class.default_appid ).to eq( 'acme-valhalla-eventserver' )
 	end
 
 
-	#
-	# Control frame defaults
-	#
+	it "accepts websocket handshakes" do
+		app = app_class.new
+		request = @request_factory.handshake( '/chat' )
 
-	it "returns a PONG for PING frames" do
-		ping = @frame_factory.ping( '/chat' )
-		res = @app.new.handle_websocket( ping )
+		res = app.dispatch_request( request )
 
-		expect( res ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( res.opcode ).to eq( :pong )
-		expect( res.socket_id ).to eq( ping.socket_id )
+		expect( res ).to be_a( Mongrel2::WebSocket::ServerHandshake )
 	end
 
-	it "ignores PONG frames" do
-		pong = @frame_factory.pong( '/chat' )
-		res = @app.new.handle_websocket( pong )
 
-		expect( res ).to be_nil()
-	end
+	describe "control frame defaults" do
 
-	it "closes the connection on CLOSE frames" do
-		app = @app.new
-		close = @frame_factory.close( '/chat' )
+		it "returns a PONG response for PING requests" do
+			ping = @request_factory.ping( '/chat' )
 
-		expect( app.conn ).to receive( :reply_close ).with( close )
+			res = app_class.new.dispatch_request( ping )
 
-		res = app.handle_websocket( close )
-		expect( res ).to be_nil()
-	end
+			expect( res ).to be_a( Mongrel2::WebSocket::Response )
+			expect( res.opcode ).to eq( :pong )
+			expect( res.socket_id ).to eq( ping.socket_id )
+		end
 
-	it "closes the connection with an appropriate error for reserved control opcodes" do
-		reserved = @frame_factory.create( '/chat', '', 0xB )
-		res = @app.new.handle_websocket( reserved )
 
-		expect( res ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( res.opcode ).to eq( :close )
-		res.payload.rewind
-		expect( res.payload.read ).to match( /Unhandled data type/i )
-		expect( res.socket_id ).to eq( reserved.socket_id )
-	end
+		it "ignores PONG requests" do
+			pong = @request_factory.pong( '/chat' )
 
-	#
-	# Content frame defaults
-	#
+			res = app_class.new.dispatch_request( pong )
 
-	it "replies with a close frame with a bad data type error for TEXT frames" do
-		app = @app.new
-		frame = @frame_factory.text( '/chat' )
+			expect( res ).to be_nil()
+		end
 
-		res = app.handle_websocket( frame )
-		expect( res ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( res.opcode ).to eq( :close )
-		res.payload.rewind
-		expect( res.payload.read ).to match( /Unhandled data type/i )
-	end
 
-	it "replies with a close frame with a bad data type error for BINARY frames" do
-		app = @app.new
-		frame = @frame_factory.binary( '/chat' )
+		it "closes the connection on CLOSE requests" do
+			app = app_class.new
+			close = @request_factory.close( '/chat' )
+
+			expect( app.conn ).to receive( :reply_close ).with( close )
+
+			res = app.dispatch_request( close )
+
+			expect( res ).to be_nil()
+		end
+
+
+		it "closes the connection with an appropriate error for reserved control opcodes" do
+			reserved = @request_factory.create( '/chat', '', 0xB )
+
+			res = app_class.new.dispatch_request( reserved )
+
+			expect( res ).to be_a( Mongrel2::WebSocket::Response )
+			expect( res.opcode ).to eq( :close )
+
+			res.payload.rewind
+			expect( res.payload.read ).to match( /Unhandled data type/i )
+			expect( res.socket_id ).to eq( reserved.socket_id )
+		end
 
-		res = app.handle_websocket( frame )
-		expect( res ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( res.opcode ).to eq( :close )
-		res.payload.rewind
-		expect( res.payload.read ).to match( /Unhandled data type/i )
 	end
 
-	it "replies with a close frame with a bad data type error for CONTINUATION frames" do
-		app = @app.new
-		frame = @frame_factory.continuation( '/chat' )
 
-		res = app.handle_websocket( frame )
-		expect( res ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( res.opcode ).to eq( :close )
-		res.payload.rewind
-		expect( res.payload.read ).to match( /Unhandled data type/i )
+	describe "content frame defaults" do
+
+		it "replies with a close frame with a bad data type error for TEXT requests" do
+			app = app_class.new
+			frame = @request_factory.text( '/chat' )
+
+			res = app.dispatch_request( frame )
+
+			expect( res ).to be_a( Mongrel2::WebSocket::Response )
+			expect( res.opcode ).to eq( :close )
+
+			res.payload.rewind
+			expect( res.payload.read ).to match( /Unhandled data type/i )
+		end
+
+
+		it "replies with a close frame with a bad data type error for BINARY requests" do
+			app = app_class.new
+			frame = @request_factory.binary( '/chat' )
+
+			res = app.dispatch_request( frame )
+
+			expect( res ).to be_a( Mongrel2::WebSocket::Response )
+			expect( res.opcode ).to eq( :close )
+
+			res.payload.rewind
+			expect( res.payload.read ).to match( /Unhandled data type/i )
+		end
+
+
+		it "replies with a close frame with a bad data type error for CONTINUATION requests" do
+			app = app_class.new
+			frame = @request_factory.continuation( '/chat' )
+
+			res = app.dispatch_request( frame )
+
+			expect( res ).to be_a( Mongrel2::WebSocket::Response )
+			expect( res.opcode ).to eq( :close )
+
+			res.payload.rewind
+			expect( res.payload.read ).to match( /Unhandled data type/i )
+		end
+
+
+		it "closes the connection with an appropriate error for reserved content opcodes" do
+			reserved = @request_factory.create( '/chat', '', 0x3 )
+
+			res = app_class.new.dispatch_request( reserved )
+
+			expect( res ).to be_a( Mongrel2::WebSocket::Response )
+			expect( res.opcode ).to eq( :close )
+
+			res.payload.rewind
+			expect( res.payload.read ).to match( /Unhandled data type/i )
+			expect( res.socket_id ).to eq( reserved.socket_id )
+		end
+
 	end
 
-	it "closes the connection with an appropriate error for reserved content opcodes" do
-		reserved = @frame_factory.create( '/chat', '', 0x3 )
-		res = @app.new.handle_websocket( reserved )
 
-		expect( res ).to be_a( Mongrel2::WebSocket::Frame )
-		expect( res.opcode ).to eq( :close )
-		res.payload.rewind
-		expect( res.payload.read ).to match( /Unhandled data type/i )
-		expect( res.socket_id ).to eq( reserved.socket_id )
+	describe "connection registry" do
+
+		it "maintains a table of connections" do
+			app = app_class.new
+			request = @request_factory.handshake( '/chat' )
+
+			app.dispatch_request( request )
+
+			expect( app.connections ).to include( request.sender_id )
+			expect( app.connections[request.sender_id] ).to include( request.conn_id )
+		end
+
+
+		it "tracks when the last request from a client was" do
+			app = app_class.new
+
+			request = @request_factory.handshake( '/chat' )
+			app.dispatch_request( request )
+
+			request = @request_factory.ping( '/chat', "Hey, I'm awake!" )
+			app.dispatch_request( request )
+
+			timestamp = app.last_connection_time( request )
+
+			expect( timestamp ).to be_a( Time )
+			expect( timestamp ).to be_within( 1 ).of( Time.now )
+		end
+
 	end
 
 
+	describe "broadcasting" do
+
+		let( :sender1 ) { '2ac271e0-6dfe-11e9-904a-177944ec9af0' }
+		let( :sender2 ) { '91562be6-6dfd-11e9-bcf6-63596c9a6a08' }
+
+		let( :factory1 ) do
+			Mongrel2::WebSocketRequestFactory.new( route: '/chat', sender_id: sender1, conn_id: 1 )
+		end
+		let( :factory2 ) do
+			Mongrel2::WebSocketRequestFactory.new( route: '/chat', sender_id: sender1, conn_id: 2 )
+		end
+		let( :factory3 ) do
+			Mongrel2::WebSocketRequestFactory.new( route: '/chat', sender_id: sender2, conn_id: 1 )
+		end
+
+
+		it "can broadcast a frame to all current connections" do
+			app = app_class.new
+
+			request1 = factory1.handshake( '/chat' )
+			app.dispatch_request( request1 )
+
+			request2 = factory2.handshake( '/chat' )
+			app.dispatch_request( request2 )
+
+			request3 = factory3.handshake( '/chat' )
+			app.dispatch_request( request3 )
+
+			frame = Mongrel2::WebSocket::Frame.text( 'Server running.' )
+
+			expect( app.conn ).to receive( :broadcast ).with( sender1, [1, 2], frame.to_s )
+			expect( app.conn ).to receive( :broadcast ).with( sender2, [1], frame.to_s )
+
+			app.broadcast( frame )
+		end
+
+
+		it "can broadcast a frame to all current connections with exceptions" do
+			app = app_class.new
+
+			request1 = factory1.handshake( '/chat' )
+			app.dispatch_request( request1 )
+
+			request2 = factory2.handshake( '/chat' )
+			app.dispatch_request( request2 )
+
+			request3 = factory3.handshake( '/chat' )
+			app.dispatch_request( request3 )
+
+			frame = Mongrel2::WebSocket::Frame.text( 'Server running.' )
+
+			expect( app.conn ).to receive( :broadcast ).with( sender1, [1, 2], frame.to_s )
+			expect( app.conn ).to_not receive( :broadcast ).with( sender2, [1], frame.to_s )
+
+			app.broadcast( frame, except: [sender2, 1] )
+		end
+
+	end
+
 end