Improved test coverage.

Author: ioquatix

fixtures/async/bus/a_server.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "async/bus/server"
+require "async/bus/client"
+
+require "sus/fixtures/async"
+require "io/endpoint/bound_endpoint"
+require "tmpdir"
+
+module Async
+	module Bus
+		AServer = Sus::Shared("a server") do
+			include Sus::Fixtures::Async::ReactorContext
+			
+			let(:ipc_path) {File.join(@root, "bus.ipc")}
+			let(:endpoint) {Async::Bus::Protocol.local_endpoint(ipc_path)}
+			
+			def around(&block)
+				Dir.mktmpdir do |directory|
+					@root = directory
+					super(&block)
+				end
+			end
+			
+			def before
+				@bound_endpoint = endpoint.bound
+			end
+			
+			def after(error = nil)
+				@bound_endpoint&.close
+			end
+			
+			let(:server) {Async::Bus::Server.new(@bound_endpoint)}
+			let(:client) {Async::Bus::Client.new(endpoint)}
+		end
+	end
+end

lib/async/bus/protocol/connection.rb

@@ -130,7 +130,7 @@ def run
 						end
 					end
 				ensure
-					finalizer_task.stop
+					finalizer_task&.stop
 
 					@transactions.each do |id, transaction|
 						transaction.close

lib/async/bus/protocol/proxy.rb

@@ -6,7 +6,14 @@
 module Async
 	module Bus
 		module Protocol
+			# A proxy object that forwards method calls to a remote object.
+			#
+			# We must be extremely careful not to invoke any methods on the proxy object that would recursively call the proxy object.
 			class Proxy < BasicObject
+				# Create a new proxy object.
+				#
+				# @parameter connection [Connection] The connection to the remote object.
+				# @parameter name [Symbol] The name (address) of the remote object.
 				def initialize(connection, name)
 					@connection = connection
 					@name = name
@@ -28,24 +35,7 @@ def != object
 					@connection.invoke(@name, [:!=, object])
 				end
 
-				def eql?(other)
-					self.equal?(other)
-				end
-				
-				def methods(all = true)
-					@connection.invoke(@name, [:methods, all])
-				end
-				
-				def protected_methods(all = true)
-					@connection.invoke(@name, [:protected_methods, all])
-				end
-				
-				def public_methods(all = true)
-					@connection.invoke(@name, [:public_methods, all])
-				end
-				
 				def method_missing(*arguments, **options, &block)
-					$stderr.puts "invoke #{@name}.#{arguments}"
 					@connection.invoke(@name, arguments, options, &block)
 				end
 

test/async/bus/server.rb

@@ -3,152 +3,117 @@
 # Released under the MIT License.
 # Copyright, 2021-2025, by Samuel Williams.
 
-require "async/bus/server"
-require "async/bus/client"
-
-require "sus/fixtures/async"
-require "tmpdir"
-require "io/endpoint/bound_endpoint"
-
-class Counter
-	def initialize(count = 0)
-		@count = count
-	end
-	
-	attr :count
-	
-	def increment
-		@count += 1
-	end
-	
-	def each
-		@count.times do
-			yield Object.new
-		end
-	end
-	
-	def make
-		Object.new
-	end
-	
-	def itself(object)
-		return object
-	end
-	
-	def error(message)
-		raise message
-	end
-end
+require "async/bus/a_server"
 
 describe Async::Bus::Server do
-	include Sus::Fixtures::Async::ReactorContext
-	
-	let(:ipc_path) {File.join(@root, "bus.ipc")}
-	let(:endpoint) {Async::Bus::Protocol.local_endpoint(ipc_path)}
-	
-	def around(&block)
-		Dir.mktmpdir do |directory|
-			@root = directory
-			super(&block)
+	include Async::Bus::AServer
+	
+	with "#bind" do
+		it "can receive incoming clients and expose a bound object" do
+			server_task = Async do
+				server.accept do |connection|
+					connection.bind(:object, Object.new)
+				end
+			end
+			
+			client.connect do |connection|
+				expect(connection[:object]).to be_a(Object)
+			end
 		end
 	end
 
-	def before
-		@bound_endpoint = endpoint.bound
-	end
-	
-	def after(error = nil)
-		@bound_endpoint&.close
-	end
-	
-	let(:server) {Async::Bus::Server.new(@bound_endpoint)}
-	let(:client) {Async::Bus::Client.new(endpoint)}
-	
-	it "can receive incoming clients" do
-		server_task = Async do
-			server.accept do |connection|
-				connection.bind(:counter, Counter.new)
+	with "a bound Array instance" do
+		let(:array) {Array.new}
+		
+		def before
+			super
+			
+			@server_task = Async do
+				server.accept do |connection|
+					connection.bind(:array, array)
+				end
 			end
 		end
 
-		client.connect do |connection|
-			3.times do
-				connection[:counter].increment
+		def after(error = nil)
+			@server_task.stop
+			
+			super
+		end
+		
+		it "can add items to the array" do
+			client.connect do |connection|
+				connection[:array] << 1
 			end
 
-			expect(connection[:counter].count).to be == 3
+			expect(array).to be == [1]
 		end
-	end
-	
-	it "can return proxy objects" do
-		server_task = Async do
-			server.accept do |connection|
-				connection.bind(:counter, Counter)
+		
+		it "can use equality operators" do
+			array << 1
+			
+			client.connect do |connection|
+				expect(connection[:array] == [1]).to be_truthy
+				expect(connection[:array] != [2]).to be_truthy
 			end
 		end
 
-		client.connect do |connection|
-			counter = connection[:counter].new
+		it "can enumerate items in the array" do
+			array << 1 << 2 << 3
+			enumerated = []
 
-			3.times do
-				counter.increment
+			client.connect do |connection|
+				connection[:array].each do |item|
+					enumerated << item
+				end
 			end
 
-			expect(counter.count).to be == 3
+			expect(enumerated).to be == [1, 2, 3]
 		end
-	end
-	
-	it "can return the original object" do
-		server_task = Async do
-			server.accept do |connection|
-				connection.bind(:counter, Counter)
+		
+		it "can raise an exception" do
+			client.connect do |connection|
+				expect do
+					connection[:array]["one"]
+				end.to raise_exception(TypeError, message: be =~ /no implicit conversion of String into Integer/)
 			end
 		end
 
-		client.connect do |connection|
-			counter = connection[:counter].new
-			object = Object.new
-			
-			object2 = counter.itself(object)
-			
-			expect(object).to be_equal(object2)
+		it "can get all methods" do
+			client.connect do |connection|
+				expect(connection[:array].methods).to be == array.methods
+				expect(connection[:array].public_methods).to be == array.public_methods
+				expect(connection[:array].protected_methods).to be == array.protected_methods
+				expect(connection[:array].private_methods).to be == array.private_methods
+			end
 		end
-	end
-	
-	it "can raise error" do
-		server_task = Async do
-			server.accept do |connection|
-				connection.bind(:counter, Counter)
+		
+		it "can check if it responds to methods" do
+			client.connect do |connection|
+				expect(connection[:array].respond_to?(:each)).to be_truthy
+				expect(connection[:array].respond_to?(:no_such_method)).to be_falsey
 			end
 		end
 
-		client.connect do |connection|
-			counter = connection[:counter].new
+		it "can get a method instance and call it" do
+			array << 1 << 2 << 3
+			enumerated = []
 
-			expect do
-				counter.error("Hello")
-			end.to raise_exception(RuntimeError, message: be =~ /Hello/)
-		end
-	end
-	
-	it "can release proxy objects" do
-		server_task = Async do
-			server.accept do |connection|
-				connection.bind(:counter, Counter)
+			client.connect do |connection|
+				method = connection[:array].method(:each)
 
-				connection.bind(:objects, connection.objects)
+				method.call do |item|
+					enumerated << item
+				end
 			end
+			
+			expect(enumerated).to be == [1, 2, 3]
 		end
 
-		client.connect do |connection|
-			counter = connection[:counter].new(10)
-			
-			10.times do
-				counter.make
-				GC.start
+		it "has a __name__" do
+			client.connect do |connection|
+				expect(connection[:array].__name__).to be == :array
 			end
-			
-			expect(connection[:objects].size).to be < 10
 		end
 	end
 end